Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
525 
    Returns the final flag status.
526 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6050 anupam.sin 1340 
  def getRechargeOrdersForTransaction(self, txnId):
1341 
    """
1342 
    Returns a recharge order for a given transactionId
1343 
 
1344 
    Parameters:
1345 
     - txnId
1346 
    """
1347 
    pass
1348 
 
6048 rajveer 1349 
  def getServiceProviders(self, rechargeType):
1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
1353 
    """
1354 
    pass
6000 mandeep.dh 1355 
 
6049 rajveer 1356 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1357 
    """
1358 
    Parameters:
6049 rajveer 1359 
     - rechargeType
6048 rajveer 1360 
     - deviceNumber
1361 
    """
1362 
    pass
1363 
 
6094 rajveer 1364 
  def getRechargeOrdersForDevice(self, deviceNumber):
1365 
    """
1366 
    Parameters:
1367 
     - deviceNumber
1368 
    """
1369 
    pass
6048 rajveer 1370 
 
6094 rajveer 1371 
  def addAmountToWallet(self, userId, orderId, amount):
1372 
    """
1373 
    Parameters:
1374 
     - userId
1375 
     - orderId
1376 
     - amount
1377 
    """
1378 
    pass
1379 
 
6154 rajveer 1380 
  def getRechargeOrdersForStatus(self, status):
1381 
    """
1382 
    Parameters:
1383 
     - status
1384 
    """
1385 
    pass
6094 rajveer 1386 
 
6154 rajveer 1387 
 
3376 rajveer 1388 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1389 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1390 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1391 
 
1392 
  def createTransaction(self, transaction):
1393 
    """
1394 
    Parameters:
1395 
     - transaction
1396 
    """
1397 
    self.send_createTransaction(transaction)
132 ashish 1398 
    return self.recv_createTransaction()
94 ashish 1399 
 
1400 
  def send_createTransaction(self, transaction):
1401 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1402 
    args = createTransaction_args()
1403 
    args.transaction = transaction
1404 
    args.write(self._oprot)
1405 
    self._oprot.writeMessageEnd()
1406 
    self._oprot.trans.flush()
1407 
 
1408 
  def recv_createTransaction(self, ):
1409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1410 
    if mtype == TMessageType.EXCEPTION:
1411 
      x = TApplicationException()
1412 
      x.read(self._iprot)
1413 
      self._iprot.readMessageEnd()
1414 
      raise x
1415 
    result = createTransaction_result()
1416 
    result.read(self._iprot)
1417 
    self._iprot.readMessageEnd()
3431 rajveer 1418 
    if result.success is not None:
132 ashish 1419 
      return result.success
3431 rajveer 1420 
    if result.ex is not None:
94 ashish 1421 
      raise result.ex
132 ashish 1422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1423 
 
1424 
  def getTransaction(self, id):
1425 
    """
1426 
    Parameters:
1427 
     - id
1428 
    """
1429 
    self.send_getTransaction(id)
1430 
    return self.recv_getTransaction()
1431 
 
1432 
  def send_getTransaction(self, id):
1433 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1434 
    args = getTransaction_args()
1435 
    args.id = id
1436 
    args.write(self._oprot)
1437 
    self._oprot.writeMessageEnd()
1438 
    self._oprot.trans.flush()
1439 
 
1440 
  def recv_getTransaction(self, ):
1441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1442 
    if mtype == TMessageType.EXCEPTION:
1443 
      x = TApplicationException()
1444 
      x.read(self._iprot)
1445 
      self._iprot.readMessageEnd()
1446 
      raise x
1447 
    result = getTransaction_result()
1448 
    result.read(self._iprot)
1449 
    self._iprot.readMessageEnd()
3431 rajveer 1450 
    if result.success is not None:
94 ashish 1451 
      return result.success
3431 rajveer 1452 
    if result.ex is not None:
94 ashish 1453 
      raise result.ex
1454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1455 
 
1456 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1457 
    """
1458 
    Parameters:
1459 
     - customerId
1460 
     - from_date
1461 
     - to_date
1462 
     - status
1463 
    """
1464 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1465 
    return self.recv_getTransactionsForCustomer()
1466 
 
1467 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1468 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1469 
    args = getTransactionsForCustomer_args()
1470 
    args.customerId = customerId
1471 
    args.from_date = from_date
1472 
    args.to_date = to_date
1473 
    args.status = status
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getTransactionsForCustomer(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getTransactionsForCustomer_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
3431 rajveer 1488 
    if result.success is not None:
94 ashish 1489 
      return result.success
3431 rajveer 1490 
    if result.ex is not None:
94 ashish 1491 
      raise result.ex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1493 
 
132 ashish 1494 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1495 
    """
1496 
    Parameters:
1497 
     - shoppingCartId
1498 
    """
1499 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1500 
    return self.recv_getTransactionsForShoppingCartId()
1501 
 
1502 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1503 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1504 
    args = getTransactionsForShoppingCartId_args()
1505 
    args.shoppingCartId = shoppingCartId
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getTransactionsForShoppingCartId(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getTransactionsForShoppingCartId_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
3431 rajveer 1520 
    if result.success is not None:
132 ashish 1521 
      return result.success
3431 rajveer 1522 
    if result.ex is not None:
132 ashish 1523 
      raise result.ex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1525 
 
94 ashish 1526 
  def getTransactionStatus(self, transactionId):
1527 
    """
1528 
    Parameters:
1529 
     - transactionId
1530 
    """
1531 
    self.send_getTransactionStatus(transactionId)
1532 
    return self.recv_getTransactionStatus()
1533 
 
1534 
  def send_getTransactionStatus(self, transactionId):
1535 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1536 
    args = getTransactionStatus_args()
1537 
    args.transactionId = transactionId
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_getTransactionStatus(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = getTransactionStatus_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
3431 rajveer 1552 
    if result.success is not None:
94 ashish 1553 
      return result.success
3431 rajveer 1554 
    if result.ex is not None:
94 ashish 1555 
      raise result.ex
1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1557 
 
5527 anupam.sin 1558 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1559 
    """
1560 
    Parameters:
1561 
     - transactionId
1562 
     - status
1563 
     - description
5527 anupam.sin 1564 
     - pickUp
1565 
     - orderType
94 ashish 1566 
    """
5527 anupam.sin 1567 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1568 
    return self.recv_changeTransactionStatus()
1569 
 
5527 anupam.sin 1570 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1571 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1572 
    args = changeTransactionStatus_args()
1573 
    args.transactionId = transactionId
1574 
    args.status = status
1575 
    args.description = description
5527 anupam.sin 1576 
    args.pickUp = pickUp
1577 
    args.orderType = orderType
94 ashish 1578 
    args.write(self._oprot)
1579 
    self._oprot.writeMessageEnd()
1580 
    self._oprot.trans.flush()
1581 
 
1582 
  def recv_changeTransactionStatus(self, ):
1583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1584 
    if mtype == TMessageType.EXCEPTION:
1585 
      x = TApplicationException()
1586 
      x.read(self._iprot)
1587 
      self._iprot.readMessageEnd()
1588 
      raise x
1589 
    result = changeTransactionStatus_result()
1590 
    result.read(self._iprot)
1591 
    self._iprot.readMessageEnd()
3431 rajveer 1592 
    if result.success is not None:
94 ashish 1593 
      return result.success
3431 rajveer 1594 
    if result.ex is not None:
94 ashish 1595 
      raise result.ex
1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1597 
 
1398 varun.gupt 1598 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1599 
    """
1600 
    Parameters:
1601 
     - transactionId
1602 
    """
1398 varun.gupt 1603 
    self.send_enqueueTransactionInfoEmail(transactionId)
1604 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1605 
 
1398 varun.gupt 1606 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1607 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1608 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1609 
    args.transactionId = transactionId
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1398 varun.gupt 1614 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1398 varun.gupt 1621 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
3431 rajveer 1624 
    if result.success is not None:
1382 varun.gupt 1625 
      return result.success
3431 rajveer 1626 
    if result.ex is not None:
1382 varun.gupt 1627 
      raise result.ex
1398 varun.gupt 1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1629 
 
4801 anupam.sin 1630 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1631 
    """
1632 
    Parameters:
4801 anupam.sin 1633 
     - statuses
483 rajveer 1634 
     - from_date
1635 
     - to_date
1636 
     - warehouse_id
94 ashish 1637 
    """
4801 anupam.sin 1638 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1639 
    return self.recv_getAllOrders()
94 ashish 1640 
 
4801 anupam.sin 1641 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1642 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1643 
    args = getAllOrders_args()
4801 anupam.sin 1644 
    args.statuses = statuses
483 rajveer 1645 
    args.from_date = from_date
1646 
    args.to_date = to_date
1647 
    args.warehouse_id = warehouse_id
94 ashish 1648 
    args.write(self._oprot)
1649 
    self._oprot.writeMessageEnd()
1650 
    self._oprot.trans.flush()
1651 
 
483 rajveer 1652 
  def recv_getAllOrders(self, ):
94 ashish 1653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1654 
    if mtype == TMessageType.EXCEPTION:
1655 
      x = TApplicationException()
1656 
      x.read(self._iprot)
1657 
      self._iprot.readMessageEnd()
1658 
      raise x
483 rajveer 1659 
    result = getAllOrders_result()
94 ashish 1660 
    result.read(self._iprot)
1661 
    self._iprot.readMessageEnd()
3431 rajveer 1662 
    if result.success is not None:
94 ashish 1663 
      return result.success
3431 rajveer 1664 
    if result.ex is not None:
94 ashish 1665 
      raise result.ex
483 rajveer 1666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1667 
 
4133 chandransh 1668 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1669 
    """
1670 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1671 
    Pass the status as null and the limit as 0 to ignore them.
1672 
 
1673 
    Parameters:
1674 
     - statuses
1675 
     - offset
1676 
     - limit
1677 
     - warehouse_id
1678 
    """
1679 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1680 
    return self.recv_getOrdersInBatch()
1681 
 
1682 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1683 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1684 
    args = getOrdersInBatch_args()
1685 
    args.statuses = statuses
1686 
    args.offset = offset
1687 
    args.limit = limit
1688 
    args.warehouse_id = warehouse_id
1689 
    args.write(self._oprot)
1690 
    self._oprot.writeMessageEnd()
1691 
    self._oprot.trans.flush()
1692 
 
1693 
  def recv_getOrdersInBatch(self, ):
1694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1695 
    if mtype == TMessageType.EXCEPTION:
1696 
      x = TApplicationException()
1697 
      x.read(self._iprot)
1698 
      self._iprot.readMessageEnd()
1699 
      raise x
1700 
    result = getOrdersInBatch_result()
1701 
    result.read(self._iprot)
1702 
    self._iprot.readMessageEnd()
1703 
    if result.success is not None:
1704 
      return result.success
1705 
    if result.ex is not None:
1706 
      raise result.ex
1707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1708 
 
1709 
  def getOrderCount(self, statuses, warehouseId):
1710 
    """
1711 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1712 
 
1713 
    Parameters:
1714 
     - statuses
1715 
     - warehouseId
1716 
    """
1717 
    self.send_getOrderCount(statuses, warehouseId)
1718 
    return self.recv_getOrderCount()
1719 
 
1720 
  def send_getOrderCount(self, statuses, warehouseId):
1721 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1722 
    args = getOrderCount_args()
1723 
    args.statuses = statuses
1724 
    args.warehouseId = warehouseId
1725 
    args.write(self._oprot)
1726 
    self._oprot.writeMessageEnd()
1727 
    self._oprot.trans.flush()
1728 
 
1729 
  def recv_getOrderCount(self, ):
1730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1731 
    if mtype == TMessageType.EXCEPTION:
1732 
      x = TApplicationException()
1733 
      x.read(self._iprot)
1734 
      self._iprot.readMessageEnd()
1735 
      raise x
1736 
    result = getOrderCount_result()
1737 
    result.read(self._iprot)
1738 
    self._iprot.readMessageEnd()
1739 
    if result.success is not None:
1740 
      return result.success
1741 
    if result.ex is not None:
1742 
      raise result.ex
1743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1744 
 
999 varun.gupt 1745 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1746 
    """
1132 chandransh 1747 
    Returns orders within a range of their billing dates
3431 rajveer 1748 
 
999 varun.gupt 1749 
    Parameters:
1750 
     - status
1751 
     - start_billing_date
1752 
     - end_billing_date
1753 
     - warehouse_id
1754 
    """
1755 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1756 
    return self.recv_getOrdersByBillingDate()
1757 
 
1758 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1759 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1760 
    args = getOrdersByBillingDate_args()
1761 
    args.status = status
1762 
    args.start_billing_date = start_billing_date
1763 
    args.end_billing_date = end_billing_date
1764 
    args.warehouse_id = warehouse_id
1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1769 
  def recv_getOrdersByBillingDate(self, ):
1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1776 
    result = getOrdersByBillingDate_result()
1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
3431 rajveer 1779 
    if result.success is not None:
999 varun.gupt 1780 
      return result.success
3431 rajveer 1781 
    if result.ex is not None:
999 varun.gupt 1782 
      raise result.ex
1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1784 
 
3451 chandransh 1785 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1786 
    """
1787 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1788 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1789 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1790 
 
3427 chandransh 1791 
    Parameters:
1792 
     - fromShippingDate
1793 
     - toShippingDate
1794 
     - providerId
1795 
     - warehouseId
3451 chandransh 1796 
     - cod
3427 chandransh 1797 
    """
3451 chandransh 1798 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1799 
    return self.recv_getOrdersByShippingDate()
1800 
 
3451 chandransh 1801 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1802 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1803 
    args = getOrdersByShippingDate_args()
1804 
    args.fromShippingDate = fromShippingDate
1805 
    args.toShippingDate = toShippingDate
1806 
    args.providerId = providerId
1807 
    args.warehouseId = warehouseId
3451 chandransh 1808 
    args.cod = cod
3427 chandransh 1809 
    args.write(self._oprot)
1810 
    self._oprot.writeMessageEnd()
1811 
    self._oprot.trans.flush()
1812 
 
1813 
  def recv_getOrdersByShippingDate(self, ):
1814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1815 
    if mtype == TMessageType.EXCEPTION:
1816 
      x = TApplicationException()
1817 
      x.read(self._iprot)
1818 
      self._iprot.readMessageEnd()
1819 
      raise x
1820 
    result = getOrdersByShippingDate_result()
1821 
    result.read(self._iprot)
1822 
    self._iprot.readMessageEnd()
3431 rajveer 1823 
    if result.success is not None:
3427 chandransh 1824 
      return result.success
3431 rajveer 1825 
    if result.ex is not None:
3427 chandransh 1826 
      raise result.ex
1827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1828 
 
1382 varun.gupt 1829 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1830 
    """
1831 
    Returns order ids for orders which can be returned
3431 rajveer 1832 
 
1382 varun.gupt 1833 
    Parameters:
1834 
     - customer_id
1835 
     - limit
1836 
    """
1837 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1838 
    return self.recv_getReturnableOrdersForCustomer()
1839 
 
1840 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1841 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1842 
    args = getReturnableOrdersForCustomer_args()
1843 
    args.customer_id = customer_id
1844 
    args.limit = limit
1845 
    args.write(self._oprot)
1846 
    self._oprot.writeMessageEnd()
1847 
    self._oprot.trans.flush()
1848 
 
1849 
  def recv_getReturnableOrdersForCustomer(self, ):
1850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1851 
    if mtype == TMessageType.EXCEPTION:
1852 
      x = TApplicationException()
1853 
      x.read(self._iprot)
1854 
      self._iprot.readMessageEnd()
1855 
      raise x
1856 
    result = getReturnableOrdersForCustomer_result()
1857 
    result.read(self._iprot)
1858 
    self._iprot.readMessageEnd()
3431 rajveer 1859 
    if result.success is not None:
1382 varun.gupt 1860 
      return result.success
3431 rajveer 1861 
    if result.ex is not None:
1382 varun.gupt 1862 
      raise result.ex
1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1864 
 
1865 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1866 
    """
1867 
    Returns order ids for orders which can be cancelled
3431 rajveer 1868 
 
1382 varun.gupt 1869 
    Parameters:
1870 
     - customer_id
1871 
     - limit
1872 
    """
1873 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1874 
    return self.recv_getCancellableOrdersForCustomer()
1875 
 
1876 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1877 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1878 
    args = getCancellableOrdersForCustomer_args()
1879 
    args.customer_id = customer_id
1880 
    args.limit = limit
1881 
    args.write(self._oprot)
1882 
    self._oprot.writeMessageEnd()
1883 
    self._oprot.trans.flush()
1884 
 
1885 
  def recv_getCancellableOrdersForCustomer(self, ):
1886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1887 
    if mtype == TMessageType.EXCEPTION:
1888 
      x = TApplicationException()
1889 
      x.read(self._iprot)
1890 
      self._iprot.readMessageEnd()
1891 
      raise x
1892 
    result = getCancellableOrdersForCustomer_result()
1893 
    result.read(self._iprot)
1894 
    self._iprot.readMessageEnd()
3431 rajveer 1895 
    if result.success is not None:
1382 varun.gupt 1896 
      return result.success
3431 rajveer 1897 
    if result.ex is not None:
1382 varun.gupt 1898 
      raise result.ex
1899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1900 
 
483 rajveer 1901 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1902 
    """
1903 
    Parameters:
483 rajveer 1904 
     - orderId
1905 
     - status
1906 
     - description
94 ashish 1907 
    """
483 rajveer 1908 
    self.send_changeOrderStatus(orderId, status, description)
1909 
    return self.recv_changeOrderStatus()
94 ashish 1910 
 
483 rajveer 1911 
  def send_changeOrderStatus(self, orderId, status, description):
1912 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1913 
    args = changeOrderStatus_args()
1914 
    args.orderId = orderId
1915 
    args.status = status
1916 
    args.description = description
94 ashish 1917 
    args.write(self._oprot)
1918 
    self._oprot.writeMessageEnd()
1919 
    self._oprot.trans.flush()
1920 
 
483 rajveer 1921 
  def recv_changeOrderStatus(self, ):
94 ashish 1922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1923 
    if mtype == TMessageType.EXCEPTION:
1924 
      x = TApplicationException()
1925 
      x.read(self._iprot)
1926 
      self._iprot.readMessageEnd()
1927 
      raise x
483 rajveer 1928 
    result = changeOrderStatus_result()
94 ashish 1929 
    result.read(self._iprot)
1930 
    self._iprot.readMessageEnd()
3431 rajveer 1931 
    if result.success is not None:
94 ashish 1932 
      return result.success
3431 rajveer 1933 
    if result.ex is not None:
94 ashish 1934 
      raise result.ex
483 rajveer 1935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1936 
 
1528 ankur.sing 1937 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1938 
    """
1528 ankur.sing 1939 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1940 
    only user who owns the transaction can view its order details.
3431 rajveer 1941 
 
94 ashish 1942 
    Parameters:
1943 
     - transactionId
1528 ankur.sing 1944 
     - customerId
94 ashish 1945 
    """
1528 ankur.sing 1946 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1947 
    return self.recv_getOrdersForTransaction()
94 ashish 1948 
 
1528 ankur.sing 1949 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1950 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1951 
    args = getOrdersForTransaction_args()
94 ashish 1952 
    args.transactionId = transactionId
1528 ankur.sing 1953 
    args.customerId = customerId
94 ashish 1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
483 rajveer 1958 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
483 rajveer 1965 
    result = getOrdersForTransaction_result()
94 ashish 1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
3431 rajveer 1968 
    if result.success is not None:
94 ashish 1969 
      return result.success
3431 rajveer 1970 
    if result.ex is not None:
94 ashish 1971 
      raise result.ex
483 rajveer 1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1973 
 
3014 chandransh 1974 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1975 
    """
3014 chandransh 1976 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1977 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1978 
 
94 ashish 1979 
    Parameters:
483 rajveer 1980 
     - customerId
1981 
     - from_date
1982 
     - to_date
3014 chandransh 1983 
     - statuses
94 ashish 1984 
    """
3014 chandransh 1985 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1986 
    return self.recv_getOrdersForCustomer()
94 ashish 1987 
 
3014 chandransh 1988 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1989 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1990 
    args = getOrdersForCustomer_args()
1991 
    args.customerId = customerId
1992 
    args.from_date = from_date
1993 
    args.to_date = to_date
3014 chandransh 1994 
    args.statuses = statuses
94 ashish 1995 
    args.write(self._oprot)
1996 
    self._oprot.writeMessageEnd()
1997 
    self._oprot.trans.flush()
1998 
 
483 rajveer 1999 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2001 
    if mtype == TMessageType.EXCEPTION:
2002 
      x = TApplicationException()
2003 
      x.read(self._iprot)
2004 
      self._iprot.readMessageEnd()
2005 
      raise x
483 rajveer 2006 
    result = getOrdersForCustomer_result()
94 ashish 2007 
    result.read(self._iprot)
2008 
    self._iprot.readMessageEnd()
3431 rajveer 2009 
    if result.success is not None:
94 ashish 2010 
      return result.success
3431 rajveer 2011 
    if result.ex is not None:
94 ashish 2012 
      raise result.ex
483 rajveer 2013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2014 
 
483 rajveer 2015 
  def createOrder(self, order):
94 ashish 2016 
    """
2017 
    Parameters:
483 rajveer 2018 
     - order
94 ashish 2019 
    """
483 rajveer 2020 
    self.send_createOrder(order)
2021 
    return self.recv_createOrder()
94 ashish 2022 
 
483 rajveer 2023 
  def send_createOrder(self, order):
2024 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2025 
    args = createOrder_args()
2026 
    args.order = order
94 ashish 2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
483 rajveer 2031 
  def recv_createOrder(self, ):
94 ashish 2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
483 rajveer 2038 
    result = createOrder_result()
94 ashish 2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
3431 rajveer 2041 
    if result.success is not None:
94 ashish 2042 
      return result.success
3431 rajveer 2043 
    if result.ex is not None:
94 ashish 2044 
      raise result.ex
483 rajveer 2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2046 
 
483 rajveer 2047 
  def getOrder(self, id):
94 ashish 2048 
    """
2049 
    Parameters:
483 rajveer 2050 
     - id
94 ashish 2051 
    """
483 rajveer 2052 
    self.send_getOrder(id)
2053 
    return self.recv_getOrder()
94 ashish 2054 
 
483 rajveer 2055 
  def send_getOrder(self, id):
2056 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2057 
    args = getOrder_args()
2058 
    args.id = id
94 ashish 2059 
    args.write(self._oprot)
2060 
    self._oprot.writeMessageEnd()
2061 
    self._oprot.trans.flush()
2062 
 
483 rajveer 2063 
  def recv_getOrder(self, ):
94 ashish 2064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2065 
    if mtype == TMessageType.EXCEPTION:
2066 
      x = TApplicationException()
2067 
      x.read(self._iprot)
2068 
      self._iprot.readMessageEnd()
2069 
      raise x
483 rajveer 2070 
    result = getOrder_result()
94 ashish 2071 
    result.read(self._iprot)
2072 
    self._iprot.readMessageEnd()
3431 rajveer 2073 
    if result.success is not None:
94 ashish 2074 
      return result.success
3431 rajveer 2075 
    if result.ex is not None:
94 ashish 2076 
      raise result.ex
483 rajveer 2077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2078 
 
483 rajveer 2079 
  def getLineItemsForOrder(self, orderId):
94 ashish 2080 
    """
2081 
    Parameters:
483 rajveer 2082 
     - orderId
94 ashish 2083 
    """
483 rajveer 2084 
    self.send_getLineItemsForOrder(orderId)
2085 
    return self.recv_getLineItemsForOrder()
94 ashish 2086 
 
483 rajveer 2087 
  def send_getLineItemsForOrder(self, orderId):
2088 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2089 
    args = getLineItemsForOrder_args()
2090 
    args.orderId = orderId
94 ashish 2091 
    args.write(self._oprot)
2092 
    self._oprot.writeMessageEnd()
2093 
    self._oprot.trans.flush()
2094 
 
483 rajveer 2095 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2097 
    if mtype == TMessageType.EXCEPTION:
2098 
      x = TApplicationException()
2099 
      x.read(self._iprot)
2100 
      self._iprot.readMessageEnd()
2101 
      raise x
483 rajveer 2102 
    result = getLineItemsForOrder_result()
94 ashish 2103 
    result.read(self._iprot)
2104 
    self._iprot.readMessageEnd()
3431 rajveer 2105 
    if result.success is not None:
94 ashish 2106 
      return result.success
3431 rajveer 2107 
    if result.ex is not None:
94 ashish 2108 
      raise result.ex
483 rajveer 2109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2110 
 
4999 phani.kuma 2111 
  def getOrderList(self, order_ids):
2112 
    """
2113 
    Parameters:
2114 
     - order_ids
2115 
    """
2116 
    self.send_getOrderList(order_ids)
2117 
    return self.recv_getOrderList()
2118 
 
2119 
  def send_getOrderList(self, order_ids):
2120 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2121 
    args = getOrderList_args()
2122 
    args.order_ids = order_ids
2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
2127 
  def recv_getOrderList(self, ):
2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
2134 
    result = getOrderList_result()
2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
2137 
    if result.success is not None:
2138 
      return result.success
2139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2140 
 
5386 phani.kuma 2141 
  def getOrderListForVendor(self, order_ids, vendorId):
2142 
    """
2143 
    Parameters:
2144 
     - order_ids
2145 
     - vendorId
2146 
    """
2147 
    self.send_getOrderListForVendor(order_ids, vendorId)
2148 
    return self.recv_getOrderListForVendor()
2149 
 
2150 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2151 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2152 
    args = getOrderListForVendor_args()
2153 
    args.order_ids = order_ids
2154 
    args.vendorId = vendorId
2155 
    args.write(self._oprot)
2156 
    self._oprot.writeMessageEnd()
2157 
    self._oprot.trans.flush()
2158 
 
2159 
  def recv_getOrderListForVendor(self, ):
2160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2161 
    if mtype == TMessageType.EXCEPTION:
2162 
      x = TApplicationException()
2163 
      x.read(self._iprot)
2164 
      self._iprot.readMessageEnd()
2165 
      raise x
2166 
    result = getOrderListForVendor_result()
2167 
    result.read(self._iprot)
2168 
    self._iprot.readMessageEnd()
2169 
    if result.success is not None:
2170 
      return result.success
2171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2172 
 
1528 ankur.sing 2173 
  def getOrderForCustomer(self, orderId, customerId):
2174 
    """
2175 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2176 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2177 
 
1528 ankur.sing 2178 
    Parameters:
2179 
     - orderId
2180 
     - customerId
2181 
    """
2182 
    self.send_getOrderForCustomer(orderId, customerId)
2183 
    return self.recv_getOrderForCustomer()
2184 
 
2185 
  def send_getOrderForCustomer(self, orderId, customerId):
2186 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2187 
    args = getOrderForCustomer_args()
2188 
    args.orderId = orderId
2189 
    args.customerId = customerId
2190 
    args.write(self._oprot)
2191 
    self._oprot.writeMessageEnd()
2192 
    self._oprot.trans.flush()
2193 
 
2194 
  def recv_getOrderForCustomer(self, ):
2195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2196 
    if mtype == TMessageType.EXCEPTION:
2197 
      x = TApplicationException()
2198 
      x.read(self._iprot)
2199 
      self._iprot.readMessageEnd()
2200 
      raise x
2201 
    result = getOrderForCustomer_result()
2202 
    result.read(self._iprot)
2203 
    self._iprot.readMessageEnd()
3431 rajveer 2204 
    if result.success is not None:
1528 ankur.sing 2205 
      return result.success
3431 rajveer 2206 
    if result.ex is not None:
1528 ankur.sing 2207 
      raise result.ex
2208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2209 
 
4444 rajveer 2210 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2211 
    """
2212 
    Parameters:
4394 rajveer 2213 
     - type
4444 rajveer 2214 
     - warehouseId
4394 rajveer 2215 
     - status
2216 
     - timestamp
3064 chandransh 2217 
    """
4444 rajveer 2218 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2219 
    return self.recv_getAlerts()
2220 
 
4444 rajveer 2221 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2222 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2223 
    args = getAlerts_args()
4394 rajveer 2224 
    args.type = type
4444 rajveer 2225 
    args.warehouseId = warehouseId
4394 rajveer 2226 
    args.status = status
2227 
    args.timestamp = timestamp
3064 chandransh 2228 
    args.write(self._oprot)
2229 
    self._oprot.writeMessageEnd()
2230 
    self._oprot.trans.flush()
2231 
 
2232 
  def recv_getAlerts(self, ):
2233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2234 
    if mtype == TMessageType.EXCEPTION:
2235 
      x = TApplicationException()
2236 
      x.read(self._iprot)
2237 
      self._iprot.readMessageEnd()
2238 
      raise x
2239 
    result = getAlerts_result()
2240 
    result.read(self._iprot)
2241 
    self._iprot.readMessageEnd()
3431 rajveer 2242 
    if result.success is not None:
3064 chandransh 2243 
      return result.success
2244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2245 
 
4444 rajveer 2246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2247 
    """
2248 
    Parameters:
2249 
     - type
4444 rajveer 2250 
     - warehouseId
4394 rajveer 2251 
     - description
3064 chandransh 2252 
    """
4444 rajveer 2253 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2254 
    self.recv_addAlert()
3064 chandransh 2255 
 
4444 rajveer 2256 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2257 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2258 
    args = addAlert_args()
3064 chandransh 2259 
    args.type = type
4444 rajveer 2260 
    args.warehouseId = warehouseId
4394 rajveer 2261 
    args.description = description
3064 chandransh 2262 
    args.write(self._oprot)
2263 
    self._oprot.writeMessageEnd()
2264 
    self._oprot.trans.flush()
2265 
 
4394 rajveer 2266 
  def recv_addAlert(self, ):
3064 chandransh 2267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2268 
    if mtype == TMessageType.EXCEPTION:
2269 
      x = TApplicationException()
2270 
      x.read(self._iprot)
2271 
      self._iprot.readMessageEnd()
2272 
      raise x
4394 rajveer 2273 
    result = addAlert_result()
3064 chandransh 2274 
    result.read(self._iprot)
2275 
    self._iprot.readMessageEnd()
2276 
    return
2277 
 
4444 rajveer 2278 
  def markAlertsAsSeen(self, warehouseId):
2279 
    """
2280 
    Parameters:
2281 
     - warehouseId
2282 
    """
2283 
    self.send_markAlertsAsSeen(warehouseId)
2284 
    self.recv_markAlertsAsSeen()
2285 
 
2286 
  def send_markAlertsAsSeen(self, warehouseId):
2287 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2288 
    args = markAlertsAsSeen_args()
2289 
    args.warehouseId = warehouseId
2290 
    args.write(self._oprot)
2291 
    self._oprot.writeMessageEnd()
2292 
    self._oprot.trans.flush()
2293 
 
2294 
  def recv_markAlertsAsSeen(self, ):
2295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2296 
    if mtype == TMessageType.EXCEPTION:
2297 
      x = TApplicationException()
2298 
      x.read(self._iprot)
2299 
      self._iprot.readMessageEnd()
2300 
      raise x
2301 
    result = markAlertsAsSeen_result()
2302 
    result.read(self._iprot)
2303 
    self._iprot.readMessageEnd()
2304 
    return
2305 
 
3064 chandransh 2306 
  def getValidOrderCount(self, ):
2307 
    """
2308 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2309 
    """
2310 
    self.send_getValidOrderCount()
2311 
    return self.recv_getValidOrderCount()
2312 
 
2313 
  def send_getValidOrderCount(self, ):
2314 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2315 
    args = getValidOrderCount_args()
2316 
    args.write(self._oprot)
2317 
    self._oprot.writeMessageEnd()
2318 
    self._oprot.trans.flush()
2319 
 
2320 
  def recv_getValidOrderCount(self, ):
2321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2322 
    if mtype == TMessageType.EXCEPTION:
2323 
      x = TApplicationException()
2324 
      x.read(self._iprot)
2325 
      self._iprot.readMessageEnd()
2326 
      raise x
2327 
    result = getValidOrderCount_result()
2328 
    result.read(self._iprot)
2329 
    self._iprot.readMessageEnd()
3431 rajveer 2330 
    if result.success is not None:
3064 chandransh 2331 
      return result.success
2332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2333 
 
2334 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2335 
    """
2336 
    Returns the number of distinct customers who have done successful transactions
2337 
    """
2338 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2339 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2340 
 
2341 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2342 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2343 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2344 
    args.write(self._oprot)
2345 
    self._oprot.writeMessageEnd()
2346 
    self._oprot.trans.flush()
2347 
 
2348 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2350 
    if mtype == TMessageType.EXCEPTION:
2351 
      x = TApplicationException()
2352 
      x.read(self._iprot)
2353 
      self._iprot.readMessageEnd()
2354 
      raise x
2355 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2356 
    result.read(self._iprot)
2357 
    self._iprot.readMessageEnd()
3431 rajveer 2358 
    if result.success is not None:
3064 chandransh 2359 
      return result.success
2360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2361 
 
2362 
  def getValidOrdersAmountRange(self, ):
2363 
    """
2364 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2365 
    List contains two values, first minimum amount and second maximum amount.
2366 
    """
2367 
    self.send_getValidOrdersAmountRange()
2368 
    return self.recv_getValidOrdersAmountRange()
2369 
 
2370 
  def send_getValidOrdersAmountRange(self, ):
2371 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2372 
    args = getValidOrdersAmountRange_args()
2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
2377 
  def recv_getValidOrdersAmountRange(self, ):
2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
2384 
    result = getValidOrdersAmountRange_result()
2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
3431 rajveer 2387 
    if result.success is not None:
3064 chandransh 2388 
      return result.success
2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2390 
 
5874 rajveer 2391 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2392 
    """
2393 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2394 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2395 
 
3064 chandransh 2396 
    Parameters:
2397 
     - limit
5874 rajveer 2398 
     - onlyStore
3064 chandransh 2399 
    """
5874 rajveer 2400 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2401 
    return self.recv_getValidOrders()
2402 
 
5874 rajveer 2403 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2404 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2405 
    args = getValidOrders_args()
2406 
    args.limit = limit
5874 rajveer 2407 
    args.onlyStore = onlyStore
3064 chandransh 2408 
    args.write(self._oprot)
2409 
    self._oprot.writeMessageEnd()
2410 
    self._oprot.trans.flush()
2411 
 
2412 
  def recv_getValidOrders(self, ):
2413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2414 
    if mtype == TMessageType.EXCEPTION:
2415 
      x = TApplicationException()
2416 
      x.read(self._iprot)
2417 
      self._iprot.readMessageEnd()
2418 
      raise x
2419 
    result = getValidOrders_result()
2420 
    result.read(self._iprot)
2421 
    self._iprot.readMessageEnd()
3431 rajveer 2422 
    if result.success is not None:
3064 chandransh 2423 
      return result.success
2424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2425 
 
1220 chandransh 2426 
  def batchOrders(self, warehouseId):
2427 
    """
2428 
    Create a batch of all the pending orders for the given warehouse.
2429 
    The returned list is orderd by created_timestamp.
2430 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2431 
 
1220 chandransh 2432 
    Parameters:
2433 
     - warehouseId
2434 
    """
2435 
    self.send_batchOrders(warehouseId)
2436 
    return self.recv_batchOrders()
2437 
 
2438 
  def send_batchOrders(self, warehouseId):
2439 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2440 
    args = batchOrders_args()
2441 
    args.warehouseId = warehouseId
2442 
    args.write(self._oprot)
2443 
    self._oprot.writeMessageEnd()
2444 
    self._oprot.trans.flush()
2445 
 
2446 
  def recv_batchOrders(self, ):
2447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2448 
    if mtype == TMessageType.EXCEPTION:
2449 
      x = TApplicationException()
2450 
      x.read(self._iprot)
2451 
      self._iprot.readMessageEnd()
2452 
      raise x
2453 
    result = batchOrders_result()
2454 
    result.read(self._iprot)
2455 
    self._iprot.readMessageEnd()
3431 rajveer 2456 
    if result.success is not None:
1220 chandransh 2457 
      return result.success
3431 rajveer 2458 
    if result.ex is not None:
1220 chandransh 2459 
      raise result.ex
2460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2461 
 
1208 chandransh 2462 
  def markOrderAsOutOfStock(self, orderId):
2463 
    """
2464 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2465 
 
1208 chandransh 2466 
    Parameters:
2467 
     - orderId
2468 
    """
2469 
    self.send_markOrderAsOutOfStock(orderId)
2470 
    return self.recv_markOrderAsOutOfStock()
2471 
 
2472 
  def send_markOrderAsOutOfStock(self, orderId):
2473 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2474 
    args = markOrderAsOutOfStock_args()
2475 
    args.orderId = orderId
2476 
    args.write(self._oprot)
2477 
    self._oprot.writeMessageEnd()
2478 
    self._oprot.trans.flush()
2479 
 
2480 
  def recv_markOrderAsOutOfStock(self, ):
2481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2482 
    if mtype == TMessageType.EXCEPTION:
2483 
      x = TApplicationException()
2484 
      x.read(self._iprot)
2485 
      self._iprot.readMessageEnd()
2486 
      raise x
2487 
    result = markOrderAsOutOfStock_result()
2488 
    result.read(self._iprot)
2489 
    self._iprot.readMessageEnd()
3431 rajveer 2490 
    if result.success is not None:
1208 chandransh 2491 
      return result.success
3431 rajveer 2492 
    if result.ex is not None:
1208 chandransh 2493 
      raise result.ex
2494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2495 
 
3064 chandransh 2496 
  def verifyOrder(self, orderId):
759 chandransh 2497 
    """
3064 chandransh 2498 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2499 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2500 
    used for all other orders as well.
2501 
    Throws an exception if no such order exists.
3431 rajveer 2502 
 
759 chandransh 2503 
    Parameters:
3064 chandransh 2504 
     - orderId
759 chandransh 2505 
    """
3064 chandransh 2506 
    self.send_verifyOrder(orderId)
2507 
    return self.recv_verifyOrder()
759 chandransh 2508 
 
3064 chandransh 2509 
  def send_verifyOrder(self, orderId):
2510 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2511 
    args = verifyOrder_args()
2512 
    args.orderId = orderId
759 chandransh 2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
3064 chandransh 2517 
  def recv_verifyOrder(self, ):
759 chandransh 2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
3064 chandransh 2524 
    result = verifyOrder_result()
759 chandransh 2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
3431 rajveer 2527 
    if result.success is not None:
759 chandransh 2528 
      return result.success
3431 rajveer 2529 
    if result.ex is not None:
759 chandransh 2530 
      raise result.ex
3064 chandransh 2531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2532 
 
3064 chandransh 2533 
  def acceptOrder(self, orderId):
1113 chandransh 2534 
    """
3064 chandransh 2535 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2536 
    given order is not a COD order, it also captures the payment if the same has
2537 
    not been captured.
2538 
    Throws an exception if no such order exists.
3431 rajveer 2539 
 
1113 chandransh 2540 
    Parameters:
3064 chandransh 2541 
     - orderId
1113 chandransh 2542 
    """
3064 chandransh 2543 
    self.send_acceptOrder(orderId)
2544 
    return self.recv_acceptOrder()
1113 chandransh 2545 
 
3064 chandransh 2546 
  def send_acceptOrder(self, orderId):
2547 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2548 
    args = acceptOrder_args()
2549 
    args.orderId = orderId
1113 chandransh 2550 
    args.write(self._oprot)
2551 
    self._oprot.writeMessageEnd()
2552 
    self._oprot.trans.flush()
2553 
 
3064 chandransh 2554 
  def recv_acceptOrder(self, ):
1113 chandransh 2555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2556 
    if mtype == TMessageType.EXCEPTION:
2557 
      x = TApplicationException()
2558 
      x.read(self._iprot)
2559 
      self._iprot.readMessageEnd()
2560 
      raise x
3064 chandransh 2561 
    result = acceptOrder_result()
1113 chandransh 2562 
    result.read(self._iprot)
2563 
    self._iprot.readMessageEnd()
3431 rajveer 2564 
    if result.success is not None:
1113 chandransh 2565 
      return result.success
3431 rajveer 2566 
    if result.ex is not None:
1113 chandransh 2567 
      raise result.ex
3064 chandransh 2568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2569 
 
5110 mandeep.dh 2570 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2571 
    """
3064 chandransh 2572 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2573 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2574 
    the IMEI no. if a -1 is supplied.
2575 
    Also, it generates an invoice number for the order, marks the order as
2576 
    BILLED and sets the billing timestamp.
2577 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2578 
 
1135 chandransh 2579 
    Parameters:
3064 chandransh 2580 
     - orderId
2581 
     - invoice_number
4658 mandeep.dh 2582 
     - serialNumber
4283 anupam.sin 2583 
     - itemNumber
3064 chandransh 2584 
     - billed_by
4264 rajveer 2585 
     - jacketNumber
4283 anupam.sin 2586 
     - billingType
5110 mandeep.dh 2587 
     - fulfilmentWarehouseId
4763 rajveer 2588 
     - authorize
1135 chandransh 2589 
    """
5110 mandeep.dh 2590 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2591 
    return self.recv_addBillingDetails()
1135 chandransh 2592 
 
5110 mandeep.dh 2593 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2594 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2595 
    args = addBillingDetails_args()
2596 
    args.orderId = orderId
2597 
    args.invoice_number = invoice_number
4658 mandeep.dh 2598 
    args.serialNumber = serialNumber
4283 anupam.sin 2599 
    args.itemNumber = itemNumber
3064 chandransh 2600 
    args.billed_by = billed_by
4264 rajveer 2601 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2602 
    args.billingType = billingType
5110 mandeep.dh 2603 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2604 
    args.authorize = authorize
1135 chandransh 2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
3064 chandransh 2609 
  def recv_addBillingDetails(self, ):
1135 chandransh 2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
3064 chandransh 2616 
    result = addBillingDetails_result()
1135 chandransh 2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
3431 rajveer 2619 
    if result.success is not None:
3064 chandransh 2620 
      return result.success
3431 rajveer 2621 
    if result.ex is not None:
1135 chandransh 2622 
      raise result.ex
3064 chandransh 2623 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2624 
 
4763 rajveer 2625 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2626 
    """
2627 
    Add the invoice number to the order.
2628 
 
2629 
    Parameters:
2630 
     - orderId
2631 
     - invoiceNumber
4763 rajveer 2632 
     - color
4579 rajveer 2633 
    """
4763 rajveer 2634 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2635 
    self.recv_addInvoiceNumber()
2636 
 
4763 rajveer 2637 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2638 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2639 
    args = addInvoiceNumber_args()
2640 
    args.orderId = orderId
2641 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2642 
    args.color = color
4579 rajveer 2643 
    args.write(self._oprot)
2644 
    self._oprot.writeMessageEnd()
2645 
    self._oprot.trans.flush()
2646 
 
2647 
  def recv_addInvoiceNumber(self, ):
2648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2649 
    if mtype == TMessageType.EXCEPTION:
2650 
      x = TApplicationException()
2651 
      x.read(self._iprot)
2652 
      self._iprot.readMessageEnd()
2653 
      raise x
2654 
    result = addInvoiceNumber_result()
2655 
    result.read(self._iprot)
2656 
    self._iprot.readMessageEnd()
2657 
    if result.ex is not None:
2658 
      raise result.ex
2659 
    return
2660 
 
4910 phani.kuma 2661 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2662 
    """
3064 chandransh 2663 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2664 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2665 
 
1408 ankur.sing 2666 
    Parameters:
3064 chandransh 2667 
     - warehouseId
1408 ankur.sing 2668 
     - providerId
3064 chandransh 2669 
     - cod
4910 phani.kuma 2670 
     - orderIds
1408 ankur.sing 2671 
    """
4910 phani.kuma 2672 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2673 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2674 
 
4910 phani.kuma 2675 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2676 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2677 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2678 
    args.warehouseId = warehouseId
1408 ankur.sing 2679 
    args.providerId = providerId
3064 chandransh 2680 
    args.cod = cod
4910 phani.kuma 2681 
    args.orderIds = orderIds
1408 ankur.sing 2682 
    args.write(self._oprot)
2683 
    self._oprot.writeMessageEnd()
2684 
    self._oprot.trans.flush()
2685 
 
4910 phani.kuma 2686 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2688 
    if mtype == TMessageType.EXCEPTION:
2689 
      x = TApplicationException()
2690 
      x.read(self._iprot)
2691 
      self._iprot.readMessageEnd()
2692 
      raise x
4910 phani.kuma 2693 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2694 
    result.read(self._iprot)
2695 
    self._iprot.readMessageEnd()
3431 rajveer 2696 
    if result.success is not None:
1408 ankur.sing 2697 
      return result.success
3431 rajveer 2698 
    if result.ex is not None:
3064 chandransh 2699 
      raise result.ex
4910 phani.kuma 2700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2701 
 
5713 rajveer 2702 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2703 
    """
2704 
    Parameters:
2705 
     - providerId
2706 
     - orderIds
5713 rajveer 2707 
     - awbs
5676 rajveer 2708 
    """
5713 rajveer 2709 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2710 
    return self.recv_markOrdersAsReturnedFromStore()
2711 
 
5713 rajveer 2712 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2713 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2714 
    args = markOrdersAsReturnedFromStore_args()
2715 
    args.providerId = providerId
2716 
    args.orderIds = orderIds
5713 rajveer 2717 
    args.awbs = awbs
5676 rajveer 2718 
    args.write(self._oprot)
2719 
    self._oprot.writeMessageEnd()
2720 
    self._oprot.trans.flush()
2721 
 
2722 
  def recv_markOrdersAsReturnedFromStore(self, ):
2723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2724 
    if mtype == TMessageType.EXCEPTION:
2725 
      x = TApplicationException()
2726 
      x.read(self._iprot)
2727 
      self._iprot.readMessageEnd()
2728 
      raise x
2729 
    result = markOrdersAsReturnedFromStore_result()
2730 
    result.read(self._iprot)
2731 
    self._iprot.readMessageEnd()
2732 
    if result.success is not None:
2733 
      return result.success
2734 
    if result.ex is not None:
2735 
      raise result.ex
2736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2737 
 
4910 phani.kuma 2738 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2739 
    """
4910 phani.kuma 2740 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2741 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2742 
 
2743 
    Parameters:
2744 
     - providerId
4910 phani.kuma 2745 
     - pickupDetails
4410 rajveer 2746 
    """
4910 phani.kuma 2747 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2748 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2749 
 
4910 phani.kuma 2750 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2751 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2752 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2753 
    args.providerId = providerId
4910 phani.kuma 2754 
    args.pickupDetails = pickupDetails
4410 rajveer 2755 
    args.write(self._oprot)
2756 
    self._oprot.writeMessageEnd()
2757 
    self._oprot.trans.flush()
2758 
 
4910 phani.kuma 2759 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2761 
    if mtype == TMessageType.EXCEPTION:
2762 
      x = TApplicationException()
2763 
      x.read(self._iprot)
2764 
      self._iprot.readMessageEnd()
2765 
      raise x
4910 phani.kuma 2766 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2767 
    result.read(self._iprot)
2768 
    self._iprot.readMessageEnd()
2769 
    if result.ex is not None:
2770 
      raise result.ex
4910 phani.kuma 2771 
    return
4410 rajveer 2772 
 
4910 phani.kuma 2773 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2774 
    """
3064 chandransh 2775 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2776 
 
94 ashish 2777 
    Parameters:
3064 chandransh 2778 
     - providerId
304 ashish 2779 
    """
4910 phani.kuma 2780 
    self.send_getOrdersNotPickedUp(providerId)
2781 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2782 
 
4910 phani.kuma 2783 
  def send_getOrdersNotPickedUp(self, providerId):
2784 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2785 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2786 
    args.providerId = providerId
304 ashish 2787 
    args.write(self._oprot)
2788 
    self._oprot.writeMessageEnd()
2789 
    self._oprot.trans.flush()
2790 
 
4910 phani.kuma 2791 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2793 
    if mtype == TMessageType.EXCEPTION:
2794 
      x = TApplicationException()
2795 
      x.read(self._iprot)
2796 
      self._iprot.readMessageEnd()
2797 
      raise x
4910 phani.kuma 2798 
    result = getOrdersNotPickedUp_result()
304 ashish 2799 
    result.read(self._iprot)
2800 
    self._iprot.readMessageEnd()
3431 rajveer 2801 
    if result.success is not None:
304 ashish 2802 
      return result.success
4910 phani.kuma 2803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2804 
 
3064 chandransh 2805 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2806 
    """
3064 chandransh 2807 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2808 
    the name of the receiver.
2809 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2810 
 
304 ashish 2811 
    Parameters:
3064 chandransh 2812 
     - providerId
2813 
     - deliveredOrders
304 ashish 2814 
    """
3064 chandransh 2815 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2816 
    self.recv_markOrdersAsDelivered()
304 ashish 2817 
 
3064 chandransh 2818 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2819 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2820 
    args = markOrdersAsDelivered_args()
2821 
    args.providerId = providerId
2822 
    args.deliveredOrders = deliveredOrders
304 ashish 2823 
    args.write(self._oprot)
2824 
    self._oprot.writeMessageEnd()
2825 
    self._oprot.trans.flush()
2826 
 
3064 chandransh 2827 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2829 
    if mtype == TMessageType.EXCEPTION:
2830 
      x = TApplicationException()
2831 
      x.read(self._iprot)
2832 
      self._iprot.readMessageEnd()
2833 
      raise x
3064 chandransh 2834 
    result = markOrdersAsDelivered_result()
304 ashish 2835 
    result.read(self._iprot)
2836 
    self._iprot.readMessageEnd()
3431 rajveer 2837 
    if result.ex is not None:
3064 chandransh 2838 
      raise result.ex
304 ashish 2839 
    return
2840 
 
4910 phani.kuma 2841 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2842 
    """
4910 phani.kuma 2843 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2844 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2845 
 
3064 chandransh 2846 
    Parameters:
2847 
     - providerId
2848 
     - returnedOrders
1596 ankur.sing 2849 
    """
4910 phani.kuma 2850 
    self.send_markAsRTOrders(providerId, returnedOrders)
2851 
    self.recv_markAsRTOrders()
304 ashish 2852 
 
4910 phani.kuma 2853 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2854 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2855 
    args = markAsRTOrders_args()
3064 chandransh 2856 
    args.providerId = providerId
2857 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2858 
    args.write(self._oprot)
2859 
    self._oprot.writeMessageEnd()
2860 
    self._oprot.trans.flush()
2861 
 
4910 phani.kuma 2862 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2864 
    if mtype == TMessageType.EXCEPTION:
2865 
      x = TApplicationException()
2866 
      x.read(self._iprot)
2867 
      self._iprot.readMessageEnd()
2868 
      raise x
4910 phani.kuma 2869 
    result = markAsRTOrders_result()
1596 ankur.sing 2870 
    result.read(self._iprot)
2871 
    self._iprot.readMessageEnd()
3431 rajveer 2872 
    if result.ex is not None:
3064 chandransh 2873 
      raise result.ex
2874 
    return
1596 ankur.sing 2875 
 
4910 phani.kuma 2876 
  def getRTOrders(self, providerId):
2877 
    """
2878 
    Returns a list of orders that were returned by courier.
2879 
 
2880 
    Parameters:
2881 
     - providerId
2882 
    """
2883 
    self.send_getRTOrders(providerId)
2884 
    return self.recv_getRTOrders()
2885 
 
2886 
  def send_getRTOrders(self, providerId):
2887 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2888 
    args = getRTOrders_args()
2889 
    args.providerId = providerId
2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
2894 
  def recv_getRTOrders(self, ):
2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
2901 
    result = getRTOrders_result()
2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
2904 
    if result.success is not None:
2905 
      return result.success
2906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2907 
 
3064 chandransh 2908 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2909 
    """
3064 chandransh 2910 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2911 
 
3064 chandransh 2912 
    Parameters:
2913 
     - providerId
2914 
     - undeliveredOrders
1627 ankur.sing 2915 
    """
3064 chandransh 2916 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2917 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2918 
 
3064 chandransh 2919 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2920 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2921 
    args = updateNonDeliveryReason_args()
2922 
    args.providerId = providerId
2923 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2924 
    args.write(self._oprot)
2925 
    self._oprot.writeMessageEnd()
2926 
    self._oprot.trans.flush()
2927 
 
3064 chandransh 2928 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2930 
    if mtype == TMessageType.EXCEPTION:
2931 
      x = TApplicationException()
2932 
      x.read(self._iprot)
2933 
      self._iprot.readMessageEnd()
2934 
      raise x
3064 chandransh 2935 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2936 
    result.read(self._iprot)
2937 
    self._iprot.readMessageEnd()
4910 phani.kuma 2938 
    if result.ex is not None:
2939 
      raise result.ex
2940 
    return
2941 
 
2942 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2943 
    """
2944 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2945 
 
2946 
    Parameters:
2947 
     - providerId
2948 
    """
2949 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2950 
    return self.recv_getNonDeliveredOrdersbyCourier()
2951 
 
2952 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2953 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2954 
    args = getNonDeliveredOrdersbyCourier_args()
2955 
    args.providerId = providerId
2956 
    args.write(self._oprot)
2957 
    self._oprot.writeMessageEnd()
2958 
    self._oprot.trans.flush()
2959 
 
2960 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2962 
    if mtype == TMessageType.EXCEPTION:
2963 
      x = TApplicationException()
2964 
      x.read(self._iprot)
2965 
      self._iprot.readMessageEnd()
2966 
      raise x
2967 
    result = getNonDeliveredOrdersbyCourier_result()
2968 
    result.read(self._iprot)
2969 
    self._iprot.readMessageEnd()
4581 phani.kuma 2970 
    if result.success is not None:
2971 
      return result.success
4910 phani.kuma 2972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2973 
 
2974 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2975 
    """
2976 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2977 
 
2978 
    Parameters:
2979 
     - providerId
2980 
     - local_connected_orders
2981 
    """
2982 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2983 
    self.recv_markOrdersAsLocalConnected()
2984 
 
2985 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2986 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2987 
    args = markOrdersAsLocalConnected_args()
2988 
    args.providerId = providerId
2989 
    args.local_connected_orders = local_connected_orders
2990 
    args.write(self._oprot)
2991 
    self._oprot.writeMessageEnd()
2992 
    self._oprot.trans.flush()
2993 
 
2994 
  def recv_markOrdersAsLocalConnected(self, ):
2995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2996 
    if mtype == TMessageType.EXCEPTION:
2997 
      x = TApplicationException()
2998 
      x.read(self._iprot)
2999 
      self._iprot.readMessageEnd()
3000 
      raise x
3001 
    result = markOrdersAsLocalConnected_result()
3002 
    result.read(self._iprot)
3003 
    self._iprot.readMessageEnd()
3431 rajveer 3004 
    if result.ex is not None:
3064 chandransh 3005 
      raise result.ex
4910 phani.kuma 3006 
    return
1627 ankur.sing 3007 
 
4910 phani.kuma 3008 
  def getOrdersNotLocalConnected(self, providerId):
3009 
    """
3010 
    Returns a list of orders that were picked up or shipped but pending local connection.
3011 
 
3012 
    Parameters:
3013 
     - providerId
3014 
    """
3015 
    self.send_getOrdersNotLocalConnected(providerId)
3016 
    return self.recv_getOrdersNotLocalConnected()
3017 
 
3018 
  def send_getOrdersNotLocalConnected(self, providerId):
3019 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3020 
    args = getOrdersNotLocalConnected_args()
3021 
    args.providerId = providerId
3022 
    args.write(self._oprot)
3023 
    self._oprot.writeMessageEnd()
3024 
    self._oprot.trans.flush()
3025 
 
3026 
  def recv_getOrdersNotLocalConnected(self, ):
3027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3028 
    if mtype == TMessageType.EXCEPTION:
3029 
      x = TApplicationException()
3030 
      x.read(self._iprot)
3031 
      self._iprot.readMessageEnd()
3032 
      raise x
3033 
    result = getOrdersNotLocalConnected_result()
3034 
    result.read(self._iprot)
3035 
    self._iprot.readMessageEnd()
3036 
    if result.success is not None:
3037 
      return result.success
3038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3039 
 
3040 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3041 
    """
3042 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3043 
 
3044 
    Parameters:
3045 
     - providerId
3046 
     - destination_city_reached_orders
3047 
    """
3048 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3049 
    self.recv_markOrdersAsDestinationCityReached()
3050 
 
3051 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3052 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3053 
    args = markOrdersAsDestinationCityReached_args()
3054 
    args.providerId = providerId
3055 
    args.destination_city_reached_orders = destination_city_reached_orders
3056 
    args.write(self._oprot)
3057 
    self._oprot.writeMessageEnd()
3058 
    self._oprot.trans.flush()
3059 
 
3060 
  def recv_markOrdersAsDestinationCityReached(self, ):
3061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3062 
    if mtype == TMessageType.EXCEPTION:
3063 
      x = TApplicationException()
3064 
      x.read(self._iprot)
3065 
      self._iprot.readMessageEnd()
3066 
      raise x
3067 
    result = markOrdersAsDestinationCityReached_result()
3068 
    result.read(self._iprot)
3069 
    self._iprot.readMessageEnd()
3070 
    if result.ex is not None:
3071 
      raise result.ex
3072 
    return
3073 
 
3074 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3075 
    """
3076 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3077 
 
3078 
    Parameters:
3079 
     - providerId
3080 
     - first_atdl_orders
3081 
    """
3082 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3083 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3084 
 
3085 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3086 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3087 
    args = markOrdersAsFirstDeliveryAttempted_args()
3088 
    args.providerId = providerId
3089 
    args.first_atdl_orders = first_atdl_orders
3090 
    args.write(self._oprot)
3091 
    self._oprot.writeMessageEnd()
3092 
    self._oprot.trans.flush()
3093 
 
3094 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3096 
    if mtype == TMessageType.EXCEPTION:
3097 
      x = TApplicationException()
3098 
      x.read(self._iprot)
3099 
      self._iprot.readMessageEnd()
3100 
      raise x
3101 
    result = markOrdersAsFirstDeliveryAttempted_result()
3102 
    result.read(self._iprot)
3103 
    self._iprot.readMessageEnd()
3104 
    if result.ex is not None:
3105 
      raise result.ex
3106 
    return
3107 
 
3064 chandransh 3108 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3109 
    """
3064 chandransh 3110 
    Returns the list of orders whose delivery time has passed but have not been
3111 
    delivered yet for the given provider and warehouse. To get a complete list of
3112 
    undelivered orders, pass them as -1.
3113 
    Returns an empty list if no such orders exist.
3431 rajveer 3114 
 
1886 ankur.sing 3115 
    Parameters:
3064 chandransh 3116 
     - providerId
3117 
     - warehouseId
1886 ankur.sing 3118 
    """
3064 chandransh 3119 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3120 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3121 
 
3064 chandransh 3122 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3123 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3124 
    args = getUndeliveredOrders_args()
3125 
    args.providerId = providerId
3126 
    args.warehouseId = warehouseId
1886 ankur.sing 3127 
    args.write(self._oprot)
3128 
    self._oprot.writeMessageEnd()
3129 
    self._oprot.trans.flush()
3130 
 
3064 chandransh 3131 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3133 
    if mtype == TMessageType.EXCEPTION:
3134 
      x = TApplicationException()
3135 
      x.read(self._iprot)
3136 
      self._iprot.readMessageEnd()
3137 
      raise x
3064 chandransh 3138 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3139 
    result.read(self._iprot)
3140 
    self._iprot.readMessageEnd()
3431 rajveer 3141 
    if result.success is not None:
1886 ankur.sing 3142 
      return result.success
3064 chandransh 3143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3144 
 
4783 phani.kuma 3145 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3146 
    """
3147 
    Returns the list of orders whose expected delivery date has passed but have not been
3148 
    delivered yet.
3149 
    Returns an empty list if no such orders exist.
3150 
    """
3151 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3152 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3153 
 
3154 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3155 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3156 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3157 
    args.write(self._oprot)
3158 
    self._oprot.writeMessageEnd()
3159 
    self._oprot.trans.flush()
3160 
 
3161 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3163 
    if mtype == TMessageType.EXCEPTION:
3164 
      x = TApplicationException()
3165 
      x.read(self._iprot)
3166 
      self._iprot.readMessageEnd()
3167 
      raise x
3168 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3169 
    result.read(self._iprot)
3170 
    self._iprot.readMessageEnd()
3171 
    if result.success is not None:
3172 
      return result.success
3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3174 
 
2536 chandransh 3175 
  def toggleDOAFlag(self, orderId):
3176 
    """
3177 
    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.
3178 
    Returns the final flag status.
3179 
    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 3180 
 
2536 chandransh 3181 
    Parameters:
3182 
     - orderId
3183 
    """
3184 
    self.send_toggleDOAFlag(orderId)
3185 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3186 
 
2536 chandransh 3187 
  def send_toggleDOAFlag(self, orderId):
3188 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3189 
    args = toggleDOAFlag_args()
3190 
    args.orderId = orderId
3191 
    args.write(self._oprot)
3192 
    self._oprot.writeMessageEnd()
3193 
    self._oprot.trans.flush()
3194 
 
3195 
  def recv_toggleDOAFlag(self, ):
3196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3197 
    if mtype == TMessageType.EXCEPTION:
3198 
      x = TApplicationException()
3199 
      x.read(self._iprot)
3200 
      self._iprot.readMessageEnd()
3201 
      raise x
3202 
    result = toggleDOAFlag_result()
3203 
    result.read(self._iprot)
3204 
    self._iprot.readMessageEnd()
3431 rajveer 3205 
    if result.success is not None:
2536 chandransh 3206 
      return result.success
3431 rajveer 3207 
    if result.ex is not None:
2536 chandransh 3208 
      raise result.ex
3209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3210 
 
4712 rajveer 3211 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3212 
    """
3213 
    Parameters:
3214 
     - orderId
3215 
     - deliveryTimestamp
3216 
     - receiver
3217 
    """
3218 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3219 
    self.recv_markOrderAsDelivered()
3220 
 
3221 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3222 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3223 
    args = markOrderAsDelivered_args()
3224 
    args.orderId = orderId
3225 
    args.deliveryTimestamp = deliveryTimestamp
3226 
    args.receiver = receiver
3227 
    args.write(self._oprot)
3228 
    self._oprot.writeMessageEnd()
3229 
    self._oprot.trans.flush()
3230 
 
3231 
  def recv_markOrderAsDelivered(self, ):
3232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3233 
    if mtype == TMessageType.EXCEPTION:
3234 
      x = TApplicationException()
3235 
      x.read(self._iprot)
3236 
      self._iprot.readMessageEnd()
3237 
      raise x
3238 
    result = markOrderAsDelivered_result()
3239 
    result.read(self._iprot)
3240 
    self._iprot.readMessageEnd()
3241 
    if result.ex is not None:
3242 
      raise result.ex
3243 
    return
3244 
 
5553 rajveer 3245 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3246 
    """
3247 
    Parameters:
3248 
     - orderId
3249 
     - deliveryTimestamp
3250 
    """
3251 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3252 
    self.recv_markOrderAsReceivedAtStore()
3253 
 
3254 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3255 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3256 
    args = markOrderAsReceivedAtStore_args()
3257 
    args.orderId = orderId
3258 
    args.deliveryTimestamp = deliveryTimestamp
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_markOrderAsReceivedAtStore(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = markOrderAsReceivedAtStore_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.ex is not None:
3274 
      raise result.ex
3275 
    return
3276 
 
4454 rajveer 3277 
  def markOrderDoaRequestReceived(self, orderId):
3278 
    """
3279 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3280 
 
3281 
    Parameters:
3282 
     - orderId
3283 
    """
3284 
    self.send_markOrderDoaRequestReceived(orderId)
3285 
    return self.recv_markOrderDoaRequestReceived()
3286 
 
3287 
  def send_markOrderDoaRequestReceived(self, orderId):
3288 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3289 
    args = markOrderDoaRequestReceived_args()
3290 
    args.orderId = orderId
3291 
    args.write(self._oprot)
3292 
    self._oprot.writeMessageEnd()
3293 
    self._oprot.trans.flush()
3294 
 
3295 
  def recv_markOrderDoaRequestReceived(self, ):
3296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3297 
    if mtype == TMessageType.EXCEPTION:
3298 
      x = TApplicationException()
3299 
      x.read(self._iprot)
3300 
      self._iprot.readMessageEnd()
3301 
      raise x
3302 
    result = markOrderDoaRequestReceived_result()
3303 
    result.read(self._iprot)
3304 
    self._iprot.readMessageEnd()
3305 
    if result.success is not None:
3306 
      return result.success
3307 
    if result.ex is not None:
3308 
      raise result.ex
3309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3310 
 
3311 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3312 
    """
3313 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3314 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3315 
 
3316 
    Parameters:
3317 
     - orderId
3318 
     - isAuthorized
3319 
    """
3320 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3321 
    return self.recv_markOrderDoaRequestAuthorized()
3322 
 
3323 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3324 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3325 
    args = markOrderDoaRequestAuthorized_args()
3326 
    args.orderId = orderId
3327 
    args.isAuthorized = isAuthorized
3328 
    args.write(self._oprot)
3329 
    self._oprot.writeMessageEnd()
3330 
    self._oprot.trans.flush()
3331 
 
3332 
  def recv_markOrderDoaRequestAuthorized(self, ):
3333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3334 
    if mtype == TMessageType.EXCEPTION:
3335 
      x = TApplicationException()
3336 
      x.read(self._iprot)
3337 
      self._iprot.readMessageEnd()
3338 
      raise x
3339 
    result = markOrderDoaRequestAuthorized_result()
3340 
    result.read(self._iprot)
3341 
    self._iprot.readMessageEnd()
3342 
    if result.success is not None:
3343 
      return result.success
3344 
    if result.ex is not None:
3345 
      raise result.ex
3346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3347 
 
4488 rajveer 3348 
  def markOrderReturnRequestReceived(self, orderId):
3349 
    """
3350 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3351 
 
3352 
    Parameters:
3353 
     - orderId
3354 
    """
3355 
    self.send_markOrderReturnRequestReceived(orderId)
3356 
    return self.recv_markOrderReturnRequestReceived()
3357 
 
3358 
  def send_markOrderReturnRequestReceived(self, orderId):
3359 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3360 
    args = markOrderReturnRequestReceived_args()
3361 
    args.orderId = orderId
3362 
    args.write(self._oprot)
3363 
    self._oprot.writeMessageEnd()
3364 
    self._oprot.trans.flush()
3365 
 
3366 
  def recv_markOrderReturnRequestReceived(self, ):
3367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3368 
    if mtype == TMessageType.EXCEPTION:
3369 
      x = TApplicationException()
3370 
      x.read(self._iprot)
3371 
      self._iprot.readMessageEnd()
3372 
      raise x
3373 
    result = markOrderReturnRequestReceived_result()
3374 
    result.read(self._iprot)
3375 
    self._iprot.readMessageEnd()
3376 
    if result.success is not None:
3377 
      return result.success
3378 
    if result.ex is not None:
3379 
      raise result.ex
3380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3381 
 
3382 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3383 
    """
3384 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3385 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3386 
 
3387 
    Parameters:
3388 
     - orderId
3389 
     - isAuthorized
3390 
    """
3391 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3392 
    return self.recv_markOrderReturnRequestAuthorized()
3393 
 
3394 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3395 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3396 
    args = markOrderReturnRequestAuthorized_args()
3397 
    args.orderId = orderId
3398 
    args.isAuthorized = isAuthorized
3399 
    args.write(self._oprot)
3400 
    self._oprot.writeMessageEnd()
3401 
    self._oprot.trans.flush()
3402 
 
3403 
  def recv_markOrderReturnRequestAuthorized(self, ):
3404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3405 
    if mtype == TMessageType.EXCEPTION:
3406 
      x = TApplicationException()
3407 
      x.read(self._iprot)
3408 
      self._iprot.readMessageEnd()
3409 
      raise x
3410 
    result = markOrderReturnRequestAuthorized_result()
3411 
    result.read(self._iprot)
3412 
    self._iprot.readMessageEnd()
3413 
    if result.success is not None:
3414 
      return result.success
3415 
    if result.ex is not None:
3416 
      raise result.ex
3417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3418 
 
4579 rajveer 3419 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3420 
    """
3421 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3422 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3423 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3424 
    For any other status, it returns false.
3425 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3426 
 
2536 chandransh 3427 
    Parameters:
3428 
     - orderId
4579 rajveer 3429 
     - providerId
2536 chandransh 3430 
    """
4579 rajveer 3431 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3432 
    return self.recv_requestPickupNumber()
3433 
 
4579 rajveer 3434 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3435 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3436 
    args = requestPickupNumber_args()
3437 
    args.orderId = orderId
4579 rajveer 3438 
    args.providerId = providerId
2536 chandransh 3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_requestPickupNumber(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = requestPickupNumber_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3431 rajveer 3453 
    if result.success is not None:
2536 chandransh 3454 
      return result.success
3431 rajveer 3455 
    if result.ex is not None:
2536 chandransh 3456 
      raise result.ex
3457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3458 
 
4602 rajveer 3459 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3460 
    """
4452 rajveer 3461 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3462 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3463 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3464 
    	3. Returns true
2591 chandransh 3465 
    If the order is in any other status, it returns false.
2536 chandransh 3466 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3467 
 
2536 chandransh 3468 
    Parameters:
3469 
     - orderId
3470 
     - pickupNumber
4602 rajveer 3471 
     - providerId
2536 chandransh 3472 
    """
4602 rajveer 3473 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3474 
    return self.recv_authorizePickup()
3475 
 
4602 rajveer 3476 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3477 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3478 
    args = authorizePickup_args()
3479 
    args.orderId = orderId
3480 
    args.pickupNumber = pickupNumber
4602 rajveer 3481 
    args.providerId = providerId
2536 chandransh 3482 
    args.write(self._oprot)
3483 
    self._oprot.writeMessageEnd()
3484 
    self._oprot.trans.flush()
3485 
 
3486 
  def recv_authorizePickup(self, ):
3487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3488 
    if mtype == TMessageType.EXCEPTION:
3489 
      x = TApplicationException()
3490 
      x.read(self._iprot)
3491 
      self._iprot.readMessageEnd()
3492 
      raise x
3493 
    result = authorizePickup_result()
3494 
    result.read(self._iprot)
3495 
    self._iprot.readMessageEnd()
3431 rajveer 3496 
    if result.success is not None:
2536 chandransh 3497 
      return result.success
3431 rajveer 3498 
    if result.ex is not None:
2536 chandransh 3499 
      raise result.ex
3500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3501 
 
2764 chandransh 3502 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3503 
    """
3504 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3505 
 
2764 chandransh 3506 
    Parameters:
3507 
     - providerId
3508 
     - pickupDetails
3509 
    """
3510 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3511 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3512 
 
3513 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3514 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3515 
    args = markDoasAsPickedUp_args()
3516 
    args.providerId = providerId
3517 
    args.pickupDetails = pickupDetails
3518 
    args.write(self._oprot)
3519 
    self._oprot.writeMessageEnd()
3520 
    self._oprot.trans.flush()
3521 
 
3522 
  def recv_markDoasAsPickedUp(self, ):
3523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3524 
    if mtype == TMessageType.EXCEPTION:
3525 
      x = TApplicationException()
3526 
      x.read(self._iprot)
3527 
      self._iprot.readMessageEnd()
3528 
      raise x
3529 
    result = markDoasAsPickedUp_result()
3530 
    result.read(self._iprot)
3531 
    self._iprot.readMessageEnd()
4910 phani.kuma 3532 
    return
3533 
 
3534 
  def getDoasNotPickedUp(self, providerId):
3535 
    """
3536 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3537 
 
3538 
    Parameters:
3539 
     - providerId
3540 
    """
3541 
    self.send_getDoasNotPickedUp(providerId)
3542 
    return self.recv_getDoasNotPickedUp()
3543 
 
3544 
  def send_getDoasNotPickedUp(self, providerId):
3545 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3546 
    args = getDoasNotPickedUp_args()
3547 
    args.providerId = providerId
3548 
    args.write(self._oprot)
3549 
    self._oprot.writeMessageEnd()
3550 
    self._oprot.trans.flush()
3551 
 
3552 
  def recv_getDoasNotPickedUp(self, ):
3553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3554 
    if mtype == TMessageType.EXCEPTION:
3555 
      x = TApplicationException()
3556 
      x.read(self._iprot)
3557 
      self._iprot.readMessageEnd()
3558 
      raise x
3559 
    result = getDoasNotPickedUp_result()
3560 
    result.read(self._iprot)
3561 
    self._iprot.readMessageEnd()
3431 rajveer 3562 
    if result.success is not None:
2764 chandransh 3563 
      return result.success
4910 phani.kuma 3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3565 
 
4741 phani.kuma 3566 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3567 
    """
3568 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3569 
 
3570 
    Parameters:
3571 
     - providerId
3572 
     - pickupDetails
3573 
    """
3574 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3575 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3576 
 
3577 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3578 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3579 
    args = markReturnOrdersAsPickedUp_args()
3580 
    args.providerId = providerId
3581 
    args.pickupDetails = pickupDetails
3582 
    args.write(self._oprot)
3583 
    self._oprot.writeMessageEnd()
3584 
    self._oprot.trans.flush()
3585 
 
3586 
  def recv_markReturnOrdersAsPickedUp(self, ):
3587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3588 
    if mtype == TMessageType.EXCEPTION:
3589 
      x = TApplicationException()
3590 
      x.read(self._iprot)
3591 
      self._iprot.readMessageEnd()
3592 
      raise x
3593 
    result = markReturnOrdersAsPickedUp_result()
3594 
    result.read(self._iprot)
3595 
    self._iprot.readMessageEnd()
4910 phani.kuma 3596 
    return
3597 
 
3598 
  def getReturnOrdersNotPickedUp(self, providerId):
3599 
    """
3600 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3601 
 
3602 
    Parameters:
3603 
     - providerId
3604 
    """
3605 
    self.send_getReturnOrdersNotPickedUp(providerId)
3606 
    return self.recv_getReturnOrdersNotPickedUp()
3607 
 
3608 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3609 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3610 
    args = getReturnOrdersNotPickedUp_args()
3611 
    args.providerId = providerId
3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_getReturnOrdersNotPickedUp(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = getReturnOrdersNotPickedUp_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
4741 phani.kuma 3626 
    if result.success is not None:
3627 
      return result.success
4910 phani.kuma 3628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3629 
 
4479 rajveer 3630 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3631 
    """
4452 rajveer 3632 
    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 3633 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3634 
    If the order is in any other state, it returns false.
3635 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3636 
 
2591 chandransh 3637 
    Parameters:
3638 
     - orderId
4479 rajveer 3639 
     - receiveCondition
2591 chandransh 3640 
    """
4479 rajveer 3641 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3642 
    return self.recv_receiveReturn()
2536 chandransh 3643 
 
4479 rajveer 3644 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3645 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3646 
    args = receiveReturn_args()
2591 chandransh 3647 
    args.orderId = orderId
4479 rajveer 3648 
    args.receiveCondition = receiveCondition
2591 chandransh 3649 
    args.write(self._oprot)
3650 
    self._oprot.writeMessageEnd()
3651 
    self._oprot.trans.flush()
3652 
 
2616 chandransh 3653 
  def recv_receiveReturn(self, ):
2591 chandransh 3654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3655 
    if mtype == TMessageType.EXCEPTION:
3656 
      x = TApplicationException()
3657 
      x.read(self._iprot)
3658 
      self._iprot.readMessageEnd()
3659 
      raise x
2616 chandransh 3660 
    result = receiveReturn_result()
2591 chandransh 3661 
    result.read(self._iprot)
3662 
    self._iprot.readMessageEnd()
3431 rajveer 3663 
    if result.success is not None:
2591 chandransh 3664 
      return result.success
3431 rajveer 3665 
    if result.ex is not None:
2591 chandransh 3666 
      raise result.ex
2616 chandransh 3667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3668 
 
3669 
  def validateDoa(self, orderId, isValid):
3670 
    """
4452 rajveer 3671 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3672 
    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 3673 
    If the order is in any other state, it returns false.
3674 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3675 
 
2591 chandransh 3676 
    Parameters:
3677 
     - orderId
3678 
     - isValid
3679 
    """
3680 
    self.send_validateDoa(orderId, isValid)
3681 
    return self.recv_validateDoa()
3682 
 
3683 
  def send_validateDoa(self, orderId, isValid):
3684 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3685 
    args = validateDoa_args()
3686 
    args.orderId = orderId
3687 
    args.isValid = isValid
3688 
    args.write(self._oprot)
3689 
    self._oprot.writeMessageEnd()
3690 
    self._oprot.trans.flush()
3691 
 
3692 
  def recv_validateDoa(self, ):
3693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3694 
    if mtype == TMessageType.EXCEPTION:
3695 
      x = TApplicationException()
3696 
      x.read(self._iprot)
3697 
      self._iprot.readMessageEnd()
3698 
      raise x
3699 
    result = validateDoa_result()
3700 
    result.read(self._iprot)
3701 
    self._iprot.readMessageEnd()
3431 rajveer 3702 
    if result.success is not None:
2591 chandransh 3703 
      return result.success
3431 rajveer 3704 
    if result.ex is not None:
2591 chandransh 3705 
      raise result.ex
3706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3707 
 
4495 rajveer 3708 
  def validateReturnProduct(self, orderId, isUsable):
3709 
    """
3710 
    Parameters:
3711 
     - orderId
3712 
     - isUsable
3713 
    """
3714 
    self.send_validateReturnProduct(orderId, isUsable)
3715 
    return self.recv_validateReturnProduct()
3716 
 
3717 
  def send_validateReturnProduct(self, orderId, isUsable):
3718 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3719 
    args = validateReturnProduct_args()
3720 
    args.orderId = orderId
3721 
    args.isUsable = isUsable
3722 
    args.write(self._oprot)
3723 
    self._oprot.writeMessageEnd()
3724 
    self._oprot.trans.flush()
3725 
 
3726 
  def recv_validateReturnProduct(self, ):
3727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3728 
    if mtype == TMessageType.EXCEPTION:
3729 
      x = TApplicationException()
3730 
      x.read(self._iprot)
3731 
      self._iprot.readMessageEnd()
3732 
      raise x
3733 
    result = validateReturnProduct_result()
3734 
    result.read(self._iprot)
3735 
    self._iprot.readMessageEnd()
3736 
    if result.success is not None:
3737 
      return result.success
3738 
    if result.ex is not None:
3739 
      raise result.ex
3740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3741 
 
2616 chandransh 3742 
  def reshipOrder(self, orderId):
3743 
    """
4484 rajveer 3744 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3745 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3746 
    	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 3747 
 
3748 
    If the order is in DOA_CERT_VALID state, it does the following:
3749 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3750 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3751 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3752 
 
2616 chandransh 3753 
    Returns the id of the newly created order.
3431 rajveer 3754 
 
2616 chandransh 3755 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3756 
 
2616 chandransh 3757 
    Parameters:
3758 
     - orderId
3759 
    """
3760 
    self.send_reshipOrder(orderId)
3761 
    return self.recv_reshipOrder()
2591 chandransh 3762 
 
2616 chandransh 3763 
  def send_reshipOrder(self, orderId):
3764 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3765 
    args = reshipOrder_args()
3766 
    args.orderId = orderId
3767 
    args.write(self._oprot)
3768 
    self._oprot.writeMessageEnd()
3769 
    self._oprot.trans.flush()
3770 
 
3771 
  def recv_reshipOrder(self, ):
3772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3773 
    if mtype == TMessageType.EXCEPTION:
3774 
      x = TApplicationException()
3775 
      x.read(self._iprot)
3776 
      self._iprot.readMessageEnd()
3777 
      raise x
3778 
    result = reshipOrder_result()
3779 
    result.read(self._iprot)
3780 
    self._iprot.readMessageEnd()
3431 rajveer 3781 
    if result.success is not None:
2616 chandransh 3782 
      return result.success
3431 rajveer 3783 
    if result.ex is not None:
2616 chandransh 3784 
      raise result.ex
3785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3786 
 
3226 chandransh 3787 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3788 
    """
4484 rajveer 3789 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3790 
    	1. Creates a refund request for batch processing.
3791 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3792 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3793 
 
2616 chandransh 3794 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3795 
    	1. Creates a refund request for batch processing.
3226 chandransh 3796 
    	2. Cancels the reservation of the item in the warehouse.
3797 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3798 
 
3226 chandransh 3799 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3800 
    	1. Cancels the reservation of the item in the warehouse.
3801 
    	2. Marks the current order as CANCELED.
3802 
 
3803 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3804 
 
2616 chandransh 3805 
    Returns True if it is successful, False otherwise.
3431 rajveer 3806 
 
2616 chandransh 3807 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3808 
 
2616 chandransh 3809 
    Parameters:
3810 
     - orderId
3226 chandransh 3811 
     - refundedBy
3812 
     - reason
2616 chandransh 3813 
    """
3226 chandransh 3814 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3815 
    return self.recv_refundOrder()
3816 
 
3226 chandransh 3817 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3818 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3819 
    args = refundOrder_args()
3820 
    args.orderId = orderId
3226 chandransh 3821 
    args.refundedBy = refundedBy
3822 
    args.reason = reason
2616 chandransh 3823 
    args.write(self._oprot)
3824 
    self._oprot.writeMessageEnd()
3825 
    self._oprot.trans.flush()
3826 
 
3827 
  def recv_refundOrder(self, ):
3828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3829 
    if mtype == TMessageType.EXCEPTION:
3830 
      x = TApplicationException()
3831 
      x.read(self._iprot)
3832 
      self._iprot.readMessageEnd()
3833 
      raise x
3834 
    result = refundOrder_result()
3835 
    result.read(self._iprot)
3836 
    self._iprot.readMessageEnd()
3431 rajveer 3837 
    if result.success is not None:
2616 chandransh 3838 
      return result.success
3431 rajveer 3839 
    if result.ex is not None:
2616 chandransh 3840 
      raise result.ex
3841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3842 
 
2690 chandransh 3843 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3844 
    """
3845 
    Get all return orders created between the from and to dates for the given warehouse.
3846 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3847 
 
2690 chandransh 3848 
    Parameters:
3849 
     - warehouseId
3850 
     - fromDate
3851 
     - toDate
3852 
    """
3853 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3854 
    return self.recv_getReturnOrders()
2616 chandransh 3855 
 
2690 chandransh 3856 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3857 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3858 
    args = getReturnOrders_args()
3859 
    args.warehouseId = warehouseId
3860 
    args.fromDate = fromDate
3861 
    args.toDate = toDate
3862 
    args.write(self._oprot)
3863 
    self._oprot.writeMessageEnd()
3864 
    self._oprot.trans.flush()
3865 
 
3866 
  def recv_getReturnOrders(self, ):
3867 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3868 
    if mtype == TMessageType.EXCEPTION:
3869 
      x = TApplicationException()
3870 
      x.read(self._iprot)
3871 
      self._iprot.readMessageEnd()
3872 
      raise x
3873 
    result = getReturnOrders_result()
3874 
    result.read(self._iprot)
3875 
    self._iprot.readMessageEnd()
3431 rajveer 3876 
    if result.success is not None:
2690 chandransh 3877 
      return result.success
3878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3879 
 
5481 phani.kuma 3880 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3881 
    """
3882 
    Get all return orders created between the from and to dates.
3883 
 
3884 
    Parameters:
3885 
     - onlyNotProcessed
3886 
     - fromDate
3887 
     - toDate
3888 
    """
3889 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3890 
    return self.recv_getAllReturnOrders()
3891 
 
3892 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3893 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3894 
    args = getAllReturnOrders_args()
3895 
    args.onlyNotProcessed = onlyNotProcessed
3896 
    args.fromDate = fromDate
3897 
    args.toDate = toDate
3898 
    args.write(self._oprot)
3899 
    self._oprot.writeMessageEnd()
3900 
    self._oprot.trans.flush()
3901 
 
3902 
  def recv_getAllReturnOrders(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 = getAllReturnOrders_result()
3910 
    result.read(self._iprot)
3911 
    self._iprot.readMessageEnd()
3912 
    if result.success is not None:
3913 
      return result.success
3914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3915 
 
2700 chandransh 3916 
  def getReturnOrder(self, id):
3917 
    """
3918 
    Returns the ReturnOrder corresponding to the given id.
3919 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3920 
 
2700 chandransh 3921 
    Parameters:
3922 
     - id
3923 
    """
3924 
    self.send_getReturnOrder(id)
3925 
    return self.recv_getReturnOrder()
3926 
 
3927 
  def send_getReturnOrder(self, id):
3928 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3929 
    args = getReturnOrder_args()
3930 
    args.id = id
3931 
    args.write(self._oprot)
3932 
    self._oprot.writeMessageEnd()
3933 
    self._oprot.trans.flush()
3934 
 
3935 
  def recv_getReturnOrder(self, ):
3936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3937 
    if mtype == TMessageType.EXCEPTION:
3938 
      x = TApplicationException()
3939 
      x.read(self._iprot)
3940 
      self._iprot.readMessageEnd()
3941 
      raise x
3942 
    result = getReturnOrder_result()
3943 
    result.read(self._iprot)
3944 
    self._iprot.readMessageEnd()
3431 rajveer 3945 
    if result.success is not None:
2700 chandransh 3946 
      return result.success
3431 rajveer 3947 
    if result.ex is not None:
2700 chandransh 3948 
      raise result.ex
3949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3950 
 
2690 chandransh 3951 
  def processReturn(self, returnOrderId):
3952 
    """
3953 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3954 
 
2690 chandransh 3955 
    Parameters:
3956 
     - returnOrderId
3957 
    """
3958 
    self.send_processReturn(returnOrderId)
3959 
    self.recv_processReturn()
3960 
 
3961 
  def send_processReturn(self, returnOrderId):
3962 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3963 
    args = processReturn_args()
3964 
    args.returnOrderId = returnOrderId
3965 
    args.write(self._oprot)
3966 
    self._oprot.writeMessageEnd()
3967 
    self._oprot.trans.flush()
3968 
 
3969 
  def recv_processReturn(self, ):
3970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3971 
    if mtype == TMessageType.EXCEPTION:
3972 
      x = TApplicationException()
3973 
      x.read(self._iprot)
3974 
      self._iprot.readMessageEnd()
3975 
      raise x
3976 
    result = processReturn_result()
3977 
    result.read(self._iprot)
3978 
    self._iprot.readMessageEnd()
3431 rajveer 3979 
    if result.ex is not None:
2690 chandransh 3980 
      raise result.ex
3981 
    return
3982 
 
3451 chandransh 3983 
  def updateWeight(self, orderId, weight):
3984 
    """
3985 
    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 3986 
 
3451 chandransh 3987 
    Parameters:
3988 
     - orderId
3989 
     - weight
3990 
    """
3991 
    self.send_updateWeight(orderId, weight)
3992 
    return self.recv_updateWeight()
3993 
 
3994 
  def send_updateWeight(self, orderId, weight):
3995 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3996 
    args = updateWeight_args()
3997 
    args.orderId = orderId
3998 
    args.weight = weight
3999 
    args.write(self._oprot)
4000 
    self._oprot.writeMessageEnd()
4001 
    self._oprot.trans.flush()
4002 
 
4003 
  def recv_updateWeight(self, ):
4004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4005 
    if mtype == TMessageType.EXCEPTION:
4006 
      x = TApplicationException()
4007 
      x.read(self._iprot)
4008 
      self._iprot.readMessageEnd()
4009 
      raise x
4010 
    result = updateWeight_result()
4011 
    result.read(self._iprot)
4012 
    self._iprot.readMessageEnd()
4013 
    if result.success is not None:
4014 
      return result.success
4015 
    if result.ex is not None:
4016 
      raise result.ex
4017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4018 
 
3469 chandransh 4019 
  def changeItem(self, orderId, itemId):
4020 
    """
4021 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4022 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4023 
 
3469 chandransh 4024 
    Parameters:
4025 
     - orderId
4026 
     - itemId
4027 
    """
4028 
    self.send_changeItem(orderId, itemId)
4029 
    return self.recv_changeItem()
4030 
 
4031 
  def send_changeItem(self, orderId, itemId):
4032 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4033 
    args = changeItem_args()
4034 
    args.orderId = orderId
4035 
    args.itemId = itemId
4036 
    args.write(self._oprot)
4037 
    self._oprot.writeMessageEnd()
4038 
    self._oprot.trans.flush()
4039 
 
4040 
  def recv_changeItem(self, ):
4041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4042 
    if mtype == TMessageType.EXCEPTION:
4043 
      x = TApplicationException()
4044 
      x.read(self._iprot)
4045 
      self._iprot.readMessageEnd()
4046 
      raise x
4047 
    result = changeItem_result()
4048 
    result.read(self._iprot)
4049 
    self._iprot.readMessageEnd()
4050 
    if result.success is not None:
4051 
      return result.success
4052 
    if result.ex is not None:
4053 
      raise result.ex
4054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4055 
 
4056 
  def shiftToWarehouse(self, orderId, warehouseId):
4057 
    """
4058 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4059 
 
4060 
    Parameters:
4061 
     - orderId
4062 
     - warehouseId
4063 
    """
4064 
    self.send_shiftToWarehouse(orderId, warehouseId)
4065 
    return self.recv_shiftToWarehouse()
4066 
 
4067 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4068 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4069 
    args = shiftToWarehouse_args()
4070 
    args.orderId = orderId
4071 
    args.warehouseId = warehouseId
4072 
    args.write(self._oprot)
4073 
    self._oprot.writeMessageEnd()
4074 
    self._oprot.trans.flush()
4075 
 
4076 
  def recv_shiftToWarehouse(self, ):
4077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4078 
    if mtype == TMessageType.EXCEPTION:
4079 
      x = TApplicationException()
4080 
      x.read(self._iprot)
4081 
      self._iprot.readMessageEnd()
4082 
      raise x
4083 
    result = shiftToWarehouse_result()
4084 
    result.read(self._iprot)
4085 
    self._iprot.readMessageEnd()
4086 
    if result.success is not None:
4087 
      return result.success
4088 
    if result.ex is not None:
4089 
      raise result.ex
4090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4091 
 
4647 rajveer 4092 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4093 
    """
4094 
    Adds the given delay reason to the given order.
3986 chandransh 4095 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4096 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4097 
 
3553 chandransh 4098 
    Parameters:
4099 
     - orderId
4100 
     - delayReason
3986 chandransh 4101 
     - furtherDelay
4647 rajveer 4102 
     - delayReasonText
3553 chandransh 4103 
    """
4647 rajveer 4104 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4105 
    return self.recv_addDelayReason()
4106 
 
4647 rajveer 4107 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4108 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4109 
    args = addDelayReason_args()
4110 
    args.orderId = orderId
4111 
    args.delayReason = delayReason
3986 chandransh 4112 
    args.furtherDelay = furtherDelay
4647 rajveer 4113 
    args.delayReasonText = delayReasonText
3553 chandransh 4114 
    args.write(self._oprot)
4115 
    self._oprot.writeMessageEnd()
4116 
    self._oprot.trans.flush()
4117 
 
4118 
  def recv_addDelayReason(self, ):
4119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4120 
    if mtype == TMessageType.EXCEPTION:
4121 
      x = TApplicationException()
4122 
      x.read(self._iprot)
4123 
      self._iprot.readMessageEnd()
4124 
      raise x
4125 
    result = addDelayReason_result()
4126 
    result.read(self._iprot)
4127 
    self._iprot.readMessageEnd()
4128 
    if result.success is not None:
4129 
      return result.success
4130 
    if result.ex is not None:
4131 
      raise result.ex
4132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4133 
 
3956 chandransh 4134 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4135 
    """
4136 
    Marks the COD orders with given AWB nos. as having been processed.
4137 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4138 
 
3956 chandransh 4139 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4140 
    1. There is no order corresponding to an AWB number.
4141 
    2. The captured amount for a payment exceeds the total payment.
4142 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4143 
 
4144 
    Parameters:
4145 
     - collectedAmountMap
4146 
     - xferBy
4147 
     - xferTxnId
4148 
     - xferDate
4149 
    """
4150 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4151 
    return self.recv_reconcileCodCollection()
4152 
 
4153 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4154 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4155 
    args = reconcileCodCollection_args()
4156 
    args.collectedAmountMap = collectedAmountMap
4157 
    args.xferBy = xferBy
4158 
    args.xferTxnId = xferTxnId
4159 
    args.xferDate = xferDate
4160 
    args.write(self._oprot)
4161 
    self._oprot.writeMessageEnd()
4162 
    self._oprot.trans.flush()
4163 
 
4164 
  def recv_reconcileCodCollection(self, ):
4165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4166 
    if mtype == TMessageType.EXCEPTION:
4167 
      x = TApplicationException()
4168 
      x.read(self._iprot)
4169 
      self._iprot.readMessageEnd()
4170 
      raise x
4171 
    result = reconcileCodCollection_result()
4172 
    result.read(self._iprot)
4173 
    self._iprot.readMessageEnd()
4174 
    if result.success is not None:
4175 
      return result.success
4176 
    if result.ex is not None:
4177 
      raise result.ex
4178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4179 
 
4008 mandeep.dh 4180 
  def getTransactionsRequiringExtraProcessing(self, category):
4181 
    """
4065 mandeep.dh 4182 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4183 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4184 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4185 
 
4008 mandeep.dh 4186 
    Parameters:
4187 
     - category
4188 
    """
4189 
    self.send_getTransactionsRequiringExtraProcessing(category)
4190 
    return self.recv_getTransactionsRequiringExtraProcessing()
4191 
 
4192 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4193 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4194 
    args = getTransactionsRequiringExtraProcessing_args()
4195 
    args.category = category
4196 
    args.write(self._oprot)
4197 
    self._oprot.writeMessageEnd()
4198 
    self._oprot.trans.flush()
4199 
 
4200 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4202 
    if mtype == TMessageType.EXCEPTION:
4203 
      x = TApplicationException()
4204 
      x.read(self._iprot)
4205 
      self._iprot.readMessageEnd()
4206 
      raise x
4207 
    result = getTransactionsRequiringExtraProcessing_result()
4208 
    result.read(self._iprot)
4209 
    self._iprot.readMessageEnd()
4210 
    if result.success is not None:
4211 
      return result.success
4212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4213 
 
4214 
  def markTransactionAsProcessed(self, transactionId, category):
4215 
    """
4216 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4217 
    It essentially deletes the transaction id record for a particular
4218 
    processing type category (if present) from DB.
4219 
    This is currently used by CRM application.
4008 mandeep.dh 4220 
 
4221 
    Parameters:
4222 
     - transactionId
4223 
     - category
4224 
    """
4225 
    self.send_markTransactionAsProcessed(transactionId, category)
4226 
    self.recv_markTransactionAsProcessed()
4227 
 
4228 
  def send_markTransactionAsProcessed(self, transactionId, category):
4229 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4230 
    args = markTransactionAsProcessed_args()
4231 
    args.transactionId = transactionId
4232 
    args.category = category
4233 
    args.write(self._oprot)
4234 
    self._oprot.writeMessageEnd()
4235 
    self._oprot.trans.flush()
4236 
 
4237 
  def recv_markTransactionAsProcessed(self, ):
4238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4239 
    if mtype == TMessageType.EXCEPTION:
4240 
      x = TApplicationException()
4241 
      x.read(self._iprot)
4242 
      self._iprot.readMessageEnd()
4243 
      raise x
4244 
    result = markTransactionAsProcessed_result()
4245 
    result.read(self._iprot)
4246 
    self._iprot.readMessageEnd()
4247 
    return
4248 
 
4018 chandransh 4249 
  def getItemWiseRiskyOrdersCount(self, ):
4250 
    """
4251 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4252 
    is defined as one whose shipping date is about to expire.
4253 
    """
4254 
    self.send_getItemWiseRiskyOrdersCount()
4255 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4256 
 
4018 chandransh 4257 
  def send_getItemWiseRiskyOrdersCount(self, ):
4258 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4259 
    args = getItemWiseRiskyOrdersCount_args()
4260 
    args.write(self._oprot)
4261 
    self._oprot.writeMessageEnd()
4262 
    self._oprot.trans.flush()
4263 
 
4264 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4266 
    if mtype == TMessageType.EXCEPTION:
4267 
      x = TApplicationException()
4268 
      x.read(self._iprot)
4269 
      self._iprot.readMessageEnd()
4270 
      raise x
4271 
    result = getItemWiseRiskyOrdersCount_result()
4272 
    result.read(self._iprot)
4273 
    self._iprot.readMessageEnd()
4274 
    if result.success is not None:
4275 
      return result.success
4276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4277 
 
4295 varun.gupt 4278 
  def getOrdersForItemIds(self, itemIds):
4279 
    """
4280 
    Returns a list of all orders which have items with given id
4281 
 
4282 
    Parameters:
4283 
     - itemIds
4284 
    """
4285 
    self.send_getOrdersForItemIds(itemIds)
4286 
    return self.recv_getOrdersForItemIds()
4287 
 
4288 
  def send_getOrdersForItemIds(self, itemIds):
4289 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4290 
    args = getOrdersForItemIds_args()
4291 
    args.itemIds = itemIds
4292 
    args.write(self._oprot)
4293 
    self._oprot.writeMessageEnd()
4294 
    self._oprot.trans.flush()
4295 
 
4296 
  def recv_getOrdersForItemIds(self, ):
4297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4298 
    if mtype == TMessageType.EXCEPTION:
4299 
      x = TApplicationException()
4300 
      x.read(self._iprot)
4301 
      self._iprot.readMessageEnd()
4302 
      raise x
4303 
    result = getOrdersForItemIds_result()
4304 
    result.read(self._iprot)
4305 
    self._iprot.readMessageEnd()
4306 
    if result.success is not None:
4307 
      return result.success
4308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4309 
 
4247 rajveer 4310 
  def markOrderCancellationRequestReceived(self, orderId):
4311 
    """
4312 
    Mark order as cancellation request received. If customer sends request of cancellation of
4313 
    a particular order, this method will be called. It will just change status of the order
4314 
    depending on its current status. It also records the previous status, so that we can move
4315 
    back to that status if cancellation request is denied.
4018 chandransh 4316 
 
4247 rajveer 4317 
    Parameters:
4318 
     - orderId
4319 
    """
4320 
    self.send_markOrderCancellationRequestReceived(orderId)
4321 
    self.recv_markOrderCancellationRequestReceived()
4322 
 
4323 
  def send_markOrderCancellationRequestReceived(self, orderId):
4324 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4325 
    args = markOrderCancellationRequestReceived_args()
4326 
    args.orderId = orderId
4327 
    args.write(self._oprot)
4328 
    self._oprot.writeMessageEnd()
4329 
    self._oprot.trans.flush()
4330 
 
4331 
  def recv_markOrderCancellationRequestReceived(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 = markOrderCancellationRequestReceived_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 markOrderCancellationRequestConfirmed(self, orderId):
4346 
    """
4347 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4348 
    cancellation request confirmed. After this OM will be able to cancel the order.
4349 
 
4350 
    Parameters:
4351 
     - orderId
4352 
    """
4353 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4354 
    self.recv_markOrderCancellationRequestConfirmed()
4355 
 
4356 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4357 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4358 
    args = markOrderCancellationRequestConfirmed_args()
4359 
    args.orderId = orderId
4360 
    args.write(self._oprot)
4361 
    self._oprot.writeMessageEnd()
4362 
    self._oprot.trans.flush()
4363 
 
4364 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4366 
    if mtype == TMessageType.EXCEPTION:
4367 
      x = TApplicationException()
4368 
      x.read(self._iprot)
4369 
      self._iprot.readMessageEnd()
4370 
      raise x
4371 
    result = markOrderCancellationRequestConfirmed_result()
4372 
    result.read(self._iprot)
4373 
    self._iprot.readMessageEnd()
4374 
    if result.ex is not None:
4375 
      raise result.ex
4376 
    return
4377 
 
4378 
  def markOrderCancellationRequestDenied(self, orderId):
4379 
    """
4380 
    If we decide to not to cancel order, we will move the order ro previous status.
4381 
 
4382 
    Parameters:
4383 
     - orderId
4384 
    """
4385 
    self.send_markOrderCancellationRequestDenied(orderId)
4386 
    self.recv_markOrderCancellationRequestDenied()
4387 
 
4388 
  def send_markOrderCancellationRequestDenied(self, orderId):
4389 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4390 
    args = markOrderCancellationRequestDenied_args()
4391 
    args.orderId = orderId
4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4396 
  def recv_markOrderCancellationRequestDenied(self, ):
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
4403 
    result = markOrderCancellationRequestDenied_result()
4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    if result.ex is not None:
4407 
      raise result.ex
4408 
    return
4409 
 
4258 rajveer 4410 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4411 
    """
4258 rajveer 4412 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4413 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4414 
 
4415 
    Parameters:
4258 rajveer 4416 
     - transactionId
4247 rajveer 4417 
    """
4258 rajveer 4418 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4419 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4420 
 
4258 rajveer 4421 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4422 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4423 
    args = markTransactionAsPaymentFlagRemoved_args()
4424 
    args.transactionId = transactionId
4247 rajveer 4425 
    args.write(self._oprot)
4426 
    self._oprot.writeMessageEnd()
4427 
    self._oprot.trans.flush()
4428 
 
4258 rajveer 4429 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4431 
    if mtype == TMessageType.EXCEPTION:
4432 
      x = TApplicationException()
4433 
      x.read(self._iprot)
4434 
      self._iprot.readMessageEnd()
4435 
      raise x
4258 rajveer 4436 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4437 
    result.read(self._iprot)
4438 
    self._iprot.readMessageEnd()
4439 
    if result.ex is not None:
4440 
      raise result.ex
4441 
    return
4442 
 
4259 anupam.sin 4443 
  def refundTransaction(self, transactionId, refundedBy, reason):
4444 
    """
4445 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4446 
    need to be cancelled
4247 rajveer 4447 
 
4259 anupam.sin 4448 
    Parameters:
4449 
     - transactionId
4450 
     - refundedBy
4451 
     - reason
4452 
    """
4453 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4454 
    self.recv_refundTransaction()
4455 
 
4456 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4457 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4458 
    args = refundTransaction_args()
4459 
    args.transactionId = transactionId
4460 
    args.refundedBy = refundedBy
4461 
    args.reason = reason
4462 
    args.write(self._oprot)
4463 
    self._oprot.writeMessageEnd()
4464 
    self._oprot.trans.flush()
4465 
 
4466 
  def recv_refundTransaction(self, ):
4467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4468 
    if mtype == TMessageType.EXCEPTION:
4469 
      x = TApplicationException()
4470 
      x.read(self._iprot)
4471 
      self._iprot.readMessageEnd()
4472 
      raise x
4473 
    result = refundTransaction_result()
4474 
    result.read(self._iprot)
4475 
    self._iprot.readMessageEnd()
4476 
    if result.ex is not None:
4477 
      raise result.ex
4478 
    return
4479 
 
4324 mandeep.dh 4480 
  def updateShipmentAddress(self, orderId, addressId):
4481 
    """
4482 
    Updates shipment address of an order. Delivery and shipping date estimates
4483 
    etc. are also updated here.
4484 
 
4485 
    Throws TransactionServiceException in case address change is not
4486 
    possible due to certain reasons such as new pincode in address is
4487 
    not serviceable etc.
4488 
 
4489 
    Parameters:
4490 
     - orderId
4491 
     - addressId
4492 
    """
4493 
    self.send_updateShipmentAddress(orderId, addressId)
4494 
    self.recv_updateShipmentAddress()
4495 
 
4496 
  def send_updateShipmentAddress(self, orderId, addressId):
4497 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4498 
    args = updateShipmentAddress_args()
4499 
    args.orderId = orderId
4500 
    args.addressId = addressId
4501 
    args.write(self._oprot)
4502 
    self._oprot.writeMessageEnd()
4503 
    self._oprot.trans.flush()
4504 
 
4505 
  def recv_updateShipmentAddress(self, ):
4506 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4507 
    if mtype == TMessageType.EXCEPTION:
4508 
      x = TApplicationException()
4509 
      x.read(self._iprot)
4510 
      self._iprot.readMessageEnd()
4511 
      raise x
4512 
    result = updateShipmentAddress_result()
4513 
    result.read(self._iprot)
4514 
    self._iprot.readMessageEnd()
4515 
    if result.ex is not None:
4516 
      raise result.ex
4517 
    return
4518 
 
4285 rajveer 4519 
  def acceptOrdersForItemId(self, itemId, inventory):
4520 
    """
4521 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4522 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4523 
 
4285 rajveer 4524 
    Parameters:
4525 
     - itemId
4526 
     - inventory
4527 
    """
4528 
    self.send_acceptOrdersForItemId(itemId, inventory)
4529 
    return self.recv_acceptOrdersForItemId()
4530 
 
4531 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4532 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4533 
    args = acceptOrdersForItemId_args()
4534 
    args.itemId = itemId
4535 
    args.inventory = inventory
4536 
    args.write(self._oprot)
4537 
    self._oprot.writeMessageEnd()
4538 
    self._oprot.trans.flush()
4539 
 
4540 
  def recv_acceptOrdersForItemId(self, ):
4541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4542 
    if mtype == TMessageType.EXCEPTION:
4543 
      x = TApplicationException()
4544 
      x.read(self._iprot)
4545 
      self._iprot.readMessageEnd()
4546 
      raise x
4547 
    result = acceptOrdersForItemId_result()
4548 
    result.read(self._iprot)
4549 
    self._iprot.readMessageEnd()
4550 
    if result.success is not None:
4551 
      return result.success
4552 
    if result.ex is not None:
4553 
      raise result.ex
4554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4555 
 
4369 rajveer 4556 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4557 
    """
4558 
    Parameters:
4559 
     - vendorId
4560 
     - itemId
4561 
     - quantity
4562 
     - estimate
4369 rajveer 4563 
     - isReminder
4303 rajveer 4564 
    """
4369 rajveer 4565 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4566 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4567 
 
4369 rajveer 4568 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4569 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4570 
    args = markOrdersAsPORaised_args()
4571 
    args.vendorId = vendorId
4572 
    args.itemId = itemId
4573 
    args.quantity = quantity
4574 
    args.estimate = estimate
4369 rajveer 4575 
    args.isReminder = isReminder
4303 rajveer 4576 
    args.write(self._oprot)
4577 
    self._oprot.writeMessageEnd()
4578 
    self._oprot.trans.flush()
4579 
 
4580 
  def recv_markOrdersAsPORaised(self, ):
4581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4582 
    if mtype == TMessageType.EXCEPTION:
4583 
      x = TApplicationException()
4584 
      x.read(self._iprot)
4585 
      self._iprot.readMessageEnd()
4586 
      raise x
4587 
    result = markOrdersAsPORaised_result()
4588 
    result.read(self._iprot)
4589 
    self._iprot.readMessageEnd()
4590 
    if result.ex is not None:
4591 
      raise result.ex
4592 
    return
4593 
 
4369 rajveer 4594 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4595 
    """
4596 
    Parameters:
4597 
     - vendorId
4598 
     - itemId
4599 
     - quantity
4600 
     - estimate
4369 rajveer 4601 
     - isReminder
4303 rajveer 4602 
    """
4369 rajveer 4603 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4604 
    self.recv_markOrdersAsReversalInitiated()
4605 
 
4369 rajveer 4606 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4607 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4608 
    args = markOrdersAsReversalInitiated_args()
4609 
    args.vendorId = vendorId
4610 
    args.itemId = itemId
4611 
    args.quantity = quantity
4612 
    args.estimate = estimate
4369 rajveer 4613 
    args.isReminder = isReminder
4303 rajveer 4614 
    args.write(self._oprot)
4615 
    self._oprot.writeMessageEnd()
4616 
    self._oprot.trans.flush()
4617 
 
4618 
  def recv_markOrdersAsReversalInitiated(self, ):
4619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4620 
    if mtype == TMessageType.EXCEPTION:
4621 
      x = TApplicationException()
4622 
      x.read(self._iprot)
4623 
      self._iprot.readMessageEnd()
4624 
      raise x
4625 
    result = markOrdersAsReversalInitiated_result()
4626 
    result.read(self._iprot)
4627 
    self._iprot.readMessageEnd()
4628 
    if result.ex is not None:
4629 
      raise result.ex
4630 
    return
4631 
 
4369 rajveer 4632 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4633 
    """
4634 
    Parameters:
4635 
     - vendorId
4636 
     - itemId
4637 
     - quantity
4638 
     - estimate
4369 rajveer 4639 
     - isReminder
4303 rajveer 4640 
    """
4369 rajveer 4641 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4642 
    self.recv_markOrdersAsNotAvailabke()
4643 
 
4369 rajveer 4644 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4645 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4646 
    args = markOrdersAsNotAvailabke_args()
4647 
    args.vendorId = vendorId
4648 
    args.itemId = itemId
4649 
    args.quantity = quantity
4650 
    args.estimate = estimate
4369 rajveer 4651 
    args.isReminder = isReminder
4303 rajveer 4652 
    args.write(self._oprot)
4653 
    self._oprot.writeMessageEnd()
4654 
    self._oprot.trans.flush()
4655 
 
4656 
  def recv_markOrdersAsNotAvailabke(self, ):
4657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4658 
    if mtype == TMessageType.EXCEPTION:
4659 
      x = TApplicationException()
4660 
      x.read(self._iprot)
4661 
      self._iprot.readMessageEnd()
4662 
      raise x
4663 
    result = markOrdersAsNotAvailabke_result()
4664 
    result.read(self._iprot)
4665 
    self._iprot.readMessageEnd()
4666 
    if result.ex is not None:
4667 
      raise result.ex
4668 
    return
4669 
 
4369 rajveer 4670 
  def markOrdersAsTimeout(self, vendorId):
4671 
    """
4672 
    Parameters:
4673 
     - vendorId
4674 
    """
4675 
    self.send_markOrdersAsTimeout(vendorId)
4676 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4677 
 
4369 rajveer 4678 
  def send_markOrdersAsTimeout(self, vendorId):
4679 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4680 
    args = markOrdersAsTimeout_args()
4681 
    args.vendorId = vendorId
4682 
    args.write(self._oprot)
4683 
    self._oprot.writeMessageEnd()
4684 
    self._oprot.trans.flush()
4685 
 
4686 
  def recv_markOrdersAsTimeout(self, ):
4687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4688 
    if mtype == TMessageType.EXCEPTION:
4689 
      x = TApplicationException()
4690 
      x.read(self._iprot)
4691 
      self._iprot.readMessageEnd()
4692 
      raise x
4693 
    result = markOrdersAsTimeout_result()
4694 
    result.read(self._iprot)
4695 
    self._iprot.readMessageEnd()
4696 
    if result.success is not None:
4697 
      return result.success
4698 
    if result.ex is not None:
4699 
      raise result.ex
4700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4701 
 
4662 rajveer 4702 
  def markOrderAsLostInTransit(self, orderId):
4703 
    """
4704 
    Mark order as LOST_IN_TRANSIT
4705 
 
4706 
    Parameters:
4707 
     - orderId
4708 
    """
4709 
    self.send_markOrderAsLostInTransit(orderId)
4710 
    return self.recv_markOrderAsLostInTransit()
4711 
 
4712 
  def send_markOrderAsLostInTransit(self, orderId):
4713 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4714 
    args = markOrderAsLostInTransit_args()
4715 
    args.orderId = orderId
4716 
    args.write(self._oprot)
4717 
    self._oprot.writeMessageEnd()
4718 
    self._oprot.trans.flush()
4719 
 
4720 
  def recv_markOrderAsLostInTransit(self, ):
4721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4722 
    if mtype == TMessageType.EXCEPTION:
4723 
      x = TApplicationException()
4724 
      x.read(self._iprot)
4725 
      self._iprot.readMessageEnd()
4726 
      raise x
4727 
    result = markOrderAsLostInTransit_result()
4728 
    result.read(self._iprot)
4729 
    self._iprot.readMessageEnd()
4730 
    if result.success is not None:
4731 
      return result.success
4732 
    if result.ex is not None:
4733 
      raise result.ex
4734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4735 
 
4386 anupam.sin 4736 
  def getOrderForAwb(self, awb):
4737 
    """
4738 
    Returns the order corresponding to an AWB number
4369 rajveer 4739 
 
4386 anupam.sin 4740 
    Parameters:
4741 
     - awb
4742 
    """
4743 
    self.send_getOrderForAwb(awb)
4744 
    return self.recv_getOrderForAwb()
4745 
 
4746 
  def send_getOrderForAwb(self, awb):
4747 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4748 
    args = getOrderForAwb_args()
4749 
    args.awb = awb
4750 
    args.write(self._oprot)
4751 
    self._oprot.writeMessageEnd()
4752 
    self._oprot.trans.flush()
4753 
 
4754 
  def recv_getOrderForAwb(self, ):
4755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4756 
    if mtype == TMessageType.EXCEPTION:
4757 
      x = TApplicationException()
4758 
      x.read(self._iprot)
4759 
      self._iprot.readMessageEnd()
4760 
      raise x
4761 
    result = getOrderForAwb_result()
4762 
    result.read(self._iprot)
4763 
    self._iprot.readMessageEnd()
4764 
    if result.success is not None:
4765 
      return result.success
4766 
    if result.ex is not None:
4767 
      raise result.ex
4768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4769 
 
4910 phani.kuma 4770 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4771 
    """
4910 phani.kuma 4772 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4773 
 
4506 phani.kuma 4774 
    Parameters:
4775 
     - logistics_provider_id
4910 phani.kuma 4776 
     - order_status_list
4506 phani.kuma 4777 
    """
4910 phani.kuma 4778 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4779 
    return self.recv_getOrdersForProviderForStatus()
4780 
 
4910 phani.kuma 4781 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4782 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4783 
    args = getOrdersForProviderForStatus_args()
4784 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4785 
    args.order_status_list = order_status_list
4506 phani.kuma 4786 
    args.write(self._oprot)
4787 
    self._oprot.writeMessageEnd()
4788 
    self._oprot.trans.flush()
4789 
 
4790 
  def recv_getOrdersForProviderForStatus(self, ):
4791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4792 
    if mtype == TMessageType.EXCEPTION:
4793 
      x = TApplicationException()
4794 
      x.read(self._iprot)
4795 
      self._iprot.readMessageEnd()
4796 
      raise x
4797 
    result = getOrdersForProviderForStatus_result()
4798 
    result.read(self._iprot)
4799 
    self._iprot.readMessageEnd()
4800 
    if result.success is not None:
4801 
      return result.success
4802 
    if result.ex is not None:
4803 
      raise result.ex
4804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4805 
 
4600 varun.gupt 4806 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4807 
    """
4808 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4809 
 
4600 varun.gupt 4810 
    Parameters:
4811 
     - vendorId
4812 
     - billingDateFrom
4813 
     - billingDateTo
4814 
    """
4815 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4816 
    return self.recv_getBilledOrdersForVendor()
4817 
 
4818 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4819 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4820 
    args = getBilledOrdersForVendor_args()
4821 
    args.vendorId = vendorId
4822 
    args.billingDateFrom = billingDateFrom
4823 
    args.billingDateTo = billingDateTo
4824 
    args.write(self._oprot)
4825 
    self._oprot.writeMessageEnd()
4826 
    self._oprot.trans.flush()
4827 
 
4828 
  def recv_getBilledOrdersForVendor(self, ):
4829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4830 
    if mtype == TMessageType.EXCEPTION:
4831 
      x = TApplicationException()
4832 
      x.read(self._iprot)
4833 
      self._iprot.readMessageEnd()
4834 
      raise x
4835 
    result = getBilledOrdersForVendor_result()
4836 
    result.read(self._iprot)
4837 
    self._iprot.readMessageEnd()
4838 
    if result.success is not None:
4839 
      return result.success
4840 
    if result.ex is not None:
4841 
      raise result.ex
4842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4843 
 
4607 rajveer 4844 
  def getSlippedSippingDateOrders(self, ):
4845 
    self.send_getSlippedSippingDateOrders()
4846 
    return self.recv_getSlippedSippingDateOrders()
4847 
 
4848 
  def send_getSlippedSippingDateOrders(self, ):
4849 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4850 
    args = getSlippedSippingDateOrders_args()
4851 
    args.write(self._oprot)
4852 
    self._oprot.writeMessageEnd()
4853 
    self._oprot.trans.flush()
4854 
 
4855 
  def recv_getSlippedSippingDateOrders(self, ):
4856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4857 
    if mtype == TMessageType.EXCEPTION:
4858 
      x = TApplicationException()
4859 
      x.read(self._iprot)
4860 
      self._iprot.readMessageEnd()
4861 
      raise x
4862 
    result = getSlippedSippingDateOrders_result()
4863 
    result.read(self._iprot)
4864 
    self._iprot.readMessageEnd()
4865 
    if result.success is not None:
4866 
      return result.success
4867 
    if result.ex is not None:
4868 
      raise result.ex
4869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4870 
 
4709 rajveer 4871 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4872 
    """
4873 
    Parameters:
4874 
     - cancelDateFrom
4875 
     - cancelDateTo
4876 
    """
4877 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4878 
    return self.recv_getCancelledOrders()
4879 
 
4880 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4881 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4882 
    args = getCancelledOrders_args()
4883 
    args.cancelDateFrom = cancelDateFrom
4884 
    args.cancelDateTo = cancelDateTo
4885 
    args.write(self._oprot)
4886 
    self._oprot.writeMessageEnd()
4887 
    self._oprot.trans.flush()
4888 
 
4889 
  def recv_getCancelledOrders(self, ):
4890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4891 
    if mtype == TMessageType.EXCEPTION:
4892 
      x = TApplicationException()
4893 
      x.read(self._iprot)
4894 
      self._iprot.readMessageEnd()
4895 
      raise x
4896 
    result = getCancelledOrders_result()
4897 
    result.read(self._iprot)
4898 
    self._iprot.readMessageEnd()
4899 
    if result.success is not None:
4900 
      return result.success
4901 
    if result.ex is not None:
4902 
      raise result.ex
4903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4904 
 
4600 varun.gupt 4905 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4906 
    """
4907 
    Parameters:
4908 
     - mapAWBAndAmount
4909 
    """
4910 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4911 
    self.recv_saveBluedartSettlements()
4912 
 
4913 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4914 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4915 
    args = saveBluedartSettlements_args()
4916 
    args.mapAWBAndAmount = mapAWBAndAmount
4917 
    args.write(self._oprot)
4918 
    self._oprot.writeMessageEnd()
4919 
    self._oprot.trans.flush()
4920 
 
4921 
  def recv_saveBluedartSettlements(self, ):
4922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4923 
    if mtype == TMessageType.EXCEPTION:
4924 
      x = TApplicationException()
4925 
      x.read(self._iprot)
4926 
      self._iprot.readMessageEnd()
4927 
      raise x
4928 
    result = saveBluedartSettlements_result()
4929 
    result.read(self._iprot)
4930 
    self._iprot.readMessageEnd()
4931 
    if result.ex is not None:
4932 
      raise result.ex
4933 
    return
4934 
 
4905 varun.gupt 4935 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4936 
    """
4937 
    Parameters:
4938 
     - settlementDate
4939 
     - paymentGatewayId
4905 varun.gupt 4940 
     - referenceId
4600 varun.gupt 4941 
     - serviceTax
4942 
     - otherCharges
4943 
     - netCollection
4944 
    """
4905 varun.gupt 4945 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4946 
    self.recv_savePaymentSettlements()
4947 
 
4905 varun.gupt 4948 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4949 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4950 
    args = savePaymentSettlements_args()
4951 
    args.settlementDate = settlementDate
4952 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4953 
    args.referenceId = referenceId
4600 varun.gupt 4954 
    args.serviceTax = serviceTax
4955 
    args.otherCharges = otherCharges
4956 
    args.netCollection = netCollection
4957 
    args.write(self._oprot)
4958 
    self._oprot.writeMessageEnd()
4959 
    self._oprot.trans.flush()
4960 
 
4961 
  def recv_savePaymentSettlements(self, ):
4962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4963 
    if mtype == TMessageType.EXCEPTION:
4964 
      x = TApplicationException()
4965 
      x.read(self._iprot)
4966 
      self._iprot.readMessageEnd()
4967 
      raise x
4968 
    result = savePaymentSettlements_result()
4969 
    result.read(self._iprot)
4970 
    self._iprot.readMessageEnd()
4971 
    if result.ex is not None:
4972 
      raise result.ex
4973 
    return
4974 
 
4975 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4976 
    """
4977 
    Parameters:
4978 
     - settlementId
4979 
     - settlementDate
4980 
     - transactionDateFrom
4981 
     - transactionDateTo
4982 
     - amount
4983 
    """
4984 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4985 
    self.recv_saveEBSSettlementSummary()
4986 
 
4987 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4988 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4989 
    args = saveEBSSettlementSummary_args()
4990 
    args.settlementId = settlementId
4991 
    args.settlementDate = settlementDate
4992 
    args.transactionDateFrom = transactionDateFrom
4993 
    args.transactionDateTo = transactionDateTo
4994 
    args.amount = amount
4995 
    args.write(self._oprot)
4996 
    self._oprot.writeMessageEnd()
4997 
    self._oprot.trans.flush()
4998 
 
4999 
  def recv_saveEBSSettlementSummary(self, ):
5000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5001 
    if mtype == TMessageType.EXCEPTION:
5002 
      x = TApplicationException()
5003 
      x.read(self._iprot)
5004 
      self._iprot.readMessageEnd()
5005 
      raise x
5006 
    result = saveEBSSettlementSummary_result()
5007 
    result.read(self._iprot)
5008 
    self._iprot.readMessageEnd()
5009 
    if result.ex is not None:
5010 
      raise result.ex
5011 
    return
5012 
 
5386 phani.kuma 5013 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5014 
    """
5015 
    Parameters:
5189 varun.gupt 5016 
     - referenceId
5017 
     - isRefund
4600 varun.gupt 5018 
    """
5386 phani.kuma 5019 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5020 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5021 
 
5386 phani.kuma 5022 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5023 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5024 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5025 
    args.referenceId = referenceId
5026 
    args.isRefund = isRefund
4600 varun.gupt 5027 
    args.write(self._oprot)
5028 
    self._oprot.writeMessageEnd()
5029 
    self._oprot.trans.flush()
5030 
 
5386 phani.kuma 5031 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5033 
    if mtype == TMessageType.EXCEPTION:
5034 
      x = TApplicationException()
5035 
      x.read(self._iprot)
5036 
      self._iprot.readMessageEnd()
5037 
      raise x
5386 phani.kuma 5038 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5039 
    result.read(self._iprot)
5040 
    self._iprot.readMessageEnd()
5041 
    if result.success is not None:
5042 
      return result.success
5043 
    if result.ex is not None:
5044 
      raise result.ex
5386 phani.kuma 5045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5046 
 
5386 phani.kuma 5047 
  def getSettlementForCod(self, orderId, isRefund):
5048 
    """
5049 
    Parameters:
5050 
     - orderId
5051 
     - isRefund
5052 
    """
5053 
    self.send_getSettlementForCod(orderId, isRefund)
5054 
    return self.recv_getSettlementForCod()
5055 
 
5056 
  def send_getSettlementForCod(self, orderId, isRefund):
5057 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5058 
    args = getSettlementForCod_args()
5059 
    args.orderId = orderId
5060 
    args.isRefund = isRefund
5061 
    args.write(self._oprot)
5062 
    self._oprot.writeMessageEnd()
5063 
    self._oprot.trans.flush()
5064 
 
5065 
  def recv_getSettlementForCod(self, ):
5066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5067 
    if mtype == TMessageType.EXCEPTION:
5068 
      x = TApplicationException()
5069 
      x.read(self._iprot)
5070 
      self._iprot.readMessageEnd()
5071 
      raise x
5072 
    result = getSettlementForCod_result()
5073 
    result.read(self._iprot)
5074 
    self._iprot.readMessageEnd()
5075 
    if result.success is not None:
5076 
      return result.success
5077 
    if result.ex is not None:
5078 
      raise result.ex
5079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5080 
 
4600 varun.gupt 5081 
  def getEBSSettlementSummaries(self, ):
5082 
    self.send_getEBSSettlementSummaries()
5083 
    return self.recv_getEBSSettlementSummaries()
5084 
 
5085 
  def send_getEBSSettlementSummaries(self, ):
5086 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5087 
    args = getEBSSettlementSummaries_args()
5088 
    args.write(self._oprot)
5089 
    self._oprot.writeMessageEnd()
5090 
    self._oprot.trans.flush()
5091 
 
5092 
  def recv_getEBSSettlementSummaries(self, ):
5093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5094 
    if mtype == TMessageType.EXCEPTION:
5095 
      x = TApplicationException()
5096 
      x.read(self._iprot)
5097 
      self._iprot.readMessageEnd()
5098 
      raise x
5099 
    result = getEBSSettlementSummaries_result()
5100 
    result.read(self._iprot)
5101 
    self._iprot.readMessageEnd()
5102 
    if result.success is not None:
5103 
      return result.success
5104 
    if result.ex is not None:
5105 
      raise result.ex
5106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5107 
 
5108 
  def markEBSSettlementUploaded(self, settlementId):
5109 
    """
5110 
    Parameters:
5111 
     - settlementId
5112 
    """
5113 
    self.send_markEBSSettlementUploaded(settlementId)
5114 
    self.recv_markEBSSettlementUploaded()
5115 
 
5116 
  def send_markEBSSettlementUploaded(self, settlementId):
5117 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5118 
    args = markEBSSettlementUploaded_args()
5119 
    args.settlementId = settlementId
5120 
    args.write(self._oprot)
5121 
    self._oprot.writeMessageEnd()
5122 
    self._oprot.trans.flush()
5123 
 
5124 
  def recv_markEBSSettlementUploaded(self, ):
5125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5126 
    if mtype == TMessageType.EXCEPTION:
5127 
      x = TApplicationException()
5128 
      x.read(self._iprot)
5129 
      self._iprot.readMessageEnd()
5130 
      raise x
5131 
    result = markEBSSettlementUploaded_result()
5132 
    result.read(self._iprot)
5133 
    self._iprot.readMessageEnd()
5134 
    if result.ex is not None:
5135 
      raise result.ex
5136 
    return
5137 
 
5138 
  def getEBSSettlementDate(self, settlementId):
5139 
    """
5140 
    Parameters:
5141 
     - settlementId
5142 
    """
5143 
    self.send_getEBSSettlementDate(settlementId)
5144 
    return self.recv_getEBSSettlementDate()
5145 
 
5146 
  def send_getEBSSettlementDate(self, settlementId):
5147 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5148 
    args = getEBSSettlementDate_args()
5149 
    args.settlementId = settlementId
5150 
    args.write(self._oprot)
5151 
    self._oprot.writeMessageEnd()
5152 
    self._oprot.trans.flush()
5153 
 
5154 
  def recv_getEBSSettlementDate(self, ):
5155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5156 
    if mtype == TMessageType.EXCEPTION:
5157 
      x = TApplicationException()
5158 
      x.read(self._iprot)
5159 
      self._iprot.readMessageEnd()
5160 
      raise x
5161 
    result = getEBSSettlementDate_result()
5162 
    result.read(self._iprot)
5163 
    self._iprot.readMessageEnd()
5164 
    if result.success is not None:
5165 
      return result.success
5166 
    if result.ex is not None:
5167 
      raise result.ex
5168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5169 
 
4715 varun.gupt 5170 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5171 
    """
5172 
    Parameters:
5173 
     - settlementDateFrom
5174 
     - settlementDateTo
5175 
     - isRefund
5176 
    """
5177 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5178 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5179 
 
4715 varun.gupt 5180 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5181 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5182 
    args = getSettlementsByDate_args()
5183 
    args.settlementDateFrom = settlementDateFrom
5184 
    args.settlementDateTo = settlementDateTo
5185 
    args.isRefund = isRefund
5186 
    args.write(self._oprot)
5187 
    self._oprot.writeMessageEnd()
5188 
    self._oprot.trans.flush()
5189 
 
5190 
  def recv_getSettlementsByDate(self, ):
5191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5192 
    if mtype == TMessageType.EXCEPTION:
5193 
      x = TApplicationException()
5194 
      x.read(self._iprot)
5195 
      self._iprot.readMessageEnd()
5196 
      raise x
5197 
    result = getSettlementsByDate_result()
5198 
    result.read(self._iprot)
5199 
    self._iprot.readMessageEnd()
5200 
    if result.success is not None:
5201 
      return result.success
5202 
    if result.ex is not None:
5203 
      raise result.ex
5204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5205 
 
5206 
  def getReshippedOrderIds(self, orderIds):
5207 
    """
5208 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5209 
 
5210 
    Parameters:
5211 
     - orderIds
5212 
    """
5213 
    self.send_getReshippedOrderIds(orderIds)
5214 
    return self.recv_getReshippedOrderIds()
5215 
 
5216 
  def send_getReshippedOrderIds(self, orderIds):
5217 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5218 
    args = getReshippedOrderIds_args()
5219 
    args.orderIds = orderIds
5220 
    args.write(self._oprot)
5221 
    self._oprot.writeMessageEnd()
5222 
    self._oprot.trans.flush()
5223 
 
5224 
  def recv_getReshippedOrderIds(self, ):
5225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5226 
    if mtype == TMessageType.EXCEPTION:
5227 
      x = TApplicationException()
5228 
      x.read(self._iprot)
5229 
      self._iprot.readMessageEnd()
5230 
      raise x
5231 
    result = getReshippedOrderIds_result()
5232 
    result.read(self._iprot)
5233 
    self._iprot.readMessageEnd()
5234 
    if result.success is not None:
5235 
      return result.success
5236 
    if result.ex is not None:
5237 
      raise result.ex
5238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5239 
 
5481 phani.kuma 5240 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5241 
    """
5242 
    Parameters:
5243 
     - vendorId
5481 phani.kuma 5244 
     - onlyVendorNotPaid
5245 
     - billingDateFrom
5246 
     - billingDateTo
4875 varun.gupt 5247 
    """
5481 phani.kuma 5248 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5249 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5250 
 
5481 phani.kuma 5251 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5252 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5253 
    args = getBilledOrders_args()
4875 varun.gupt 5254 
    args.vendorId = vendorId
5481 phani.kuma 5255 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5256 
    args.billingDateFrom = billingDateFrom
5257 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5258 
    args.write(self._oprot)
5259 
    self._oprot.writeMessageEnd()
5260 
    self._oprot.trans.flush()
5261 
 
5481 phani.kuma 5262 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5264 
    if mtype == TMessageType.EXCEPTION:
5265 
      x = TApplicationException()
5266 
      x.read(self._iprot)
5267 
      self._iprot.readMessageEnd()
5268 
      raise x
5481 phani.kuma 5269 
    result = getBilledOrders_result()
4875 varun.gupt 5270 
    result.read(self._iprot)
5271 
    self._iprot.readMessageEnd()
5272 
    if result.success is not None:
5273 
      return result.success
5274 
    if result.ex is not None:
5275 
      raise result.ex
5481 phani.kuma 5276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5277 
 
5031 varun.gupt 5278 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5279 
    """
5280 
    Parameters:
5281 
     - startDate
5282 
     - endDate
5283 
    """
5284 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5285 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5286 
 
5031 varun.gupt 5287 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5288 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5289 
    args = getStatusDistributionOfOrders_args()
5290 
    args.startDate = startDate
5291 
    args.endDate = endDate
5292 
    args.write(self._oprot)
5293 
    self._oprot.writeMessageEnd()
5294 
    self._oprot.trans.flush()
5295 
 
5296 
  def recv_getStatusDistributionOfOrders(self, ):
5297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5298 
    if mtype == TMessageType.EXCEPTION:
5299 
      x = TApplicationException()
5300 
      x.read(self._iprot)
5301 
      self._iprot.readMessageEnd()
5302 
      raise x
5303 
    result = getStatusDistributionOfOrders_result()
5304 
    result.read(self._iprot)
5305 
    self._iprot.readMessageEnd()
5306 
    if result.success is not None:
5307 
      return result.success
5308 
    if result.ex is not None:
5309 
      raise result.ex
5310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5311 
 
5067 varun.gupt 5312 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5313 
    """
5314 
    Parameters:
5315 
     - status
5316 
     - startDatetime
5317 
     - endDatetime
5318 
    """
5319 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5320 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5321 
 
5067 varun.gupt 5322 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5323 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5324 
    args = getOrderIdsForStatus_args()
5325 
    args.status = status
5326 
    args.startDatetime = startDatetime
5327 
    args.endDatetime = endDatetime
5328 
    args.write(self._oprot)
5329 
    self._oprot.writeMessageEnd()
5330 
    self._oprot.trans.flush()
5331 
 
5332 
  def recv_getOrderIdsForStatus(self, ):
5333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5334 
    if mtype == TMessageType.EXCEPTION:
5335 
      x = TApplicationException()
5336 
      x.read(self._iprot)
5337 
      self._iprot.readMessageEnd()
5338 
      raise x
5339 
    result = getOrderIdsForStatus_result()
5340 
    result.read(self._iprot)
5341 
    self._iprot.readMessageEnd()
5342 
    if result.success is not None:
5343 
      return result.success
5344 
    if result.ex is not None:
5345 
      raise result.ex
5346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5347 
 
5348 anupam.sin 5348 
  def updateCODAgent(self, agent, orderId):
5349 
    """
5350 
    Updates the agent who handled the COD verification call
5351 
 
5352 
    Parameters:
5353 
     - agent
5354 
     - orderId
5355 
    """
5356 
    self.send_updateCODAgent(agent, orderId)
5357 
    self.recv_updateCODAgent()
5358 
 
5359 
  def send_updateCODAgent(self, agent, orderId):
5360 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5361 
    args = updateCODAgent_args()
5362 
    args.agent = agent
5363 
    args.orderId = orderId
5364 
    args.write(self._oprot)
5365 
    self._oprot.writeMessageEnd()
5366 
    self._oprot.trans.flush()
5367 
 
5368 
  def recv_updateCODAgent(self, ):
5369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5370 
    if mtype == TMessageType.EXCEPTION:
5371 
      x = TApplicationException()
5372 
      x.read(self._iprot)
5373 
      self._iprot.readMessageEnd()
5374 
      raise x
5375 
    result = updateCODAgent_result()
5376 
    result.read(self._iprot)
5377 
    self._iprot.readMessageEnd()
5378 
    if result.ex is not None:
5379 
      raise result.ex
5380 
    return
5381 
 
5099 varun.gupt 5382 
  def updateOrderAsPaidToVendor(self, orderId):
5383 
    """
5384 
    Parameters:
5385 
     - orderId
5386 
    """
5387 
    self.send_updateOrderAsPaidToVendor(orderId)
5388 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5389 
 
5099 varun.gupt 5390 
  def send_updateOrderAsPaidToVendor(self, orderId):
5391 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5392 
    args = updateOrderAsPaidToVendor_args()
5393 
    args.orderId = orderId
5394 
    args.write(self._oprot)
5395 
    self._oprot.writeMessageEnd()
5396 
    self._oprot.trans.flush()
5397 
 
5398 
  def recv_updateOrderAsPaidToVendor(self, ):
5399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5400 
    if mtype == TMessageType.EXCEPTION:
5401 
      x = TApplicationException()
5402 
      x.read(self._iprot)
5403 
      self._iprot.readMessageEnd()
5404 
      raise x
5405 
    result = updateOrderAsPaidToVendor_result()
5406 
    result.read(self._iprot)
5407 
    self._iprot.readMessageEnd()
5408 
    if result.ex is not None:
5409 
      raise result.ex
5410 
    return
5411 
 
5386 phani.kuma 5412 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5413 
    """
5414 
    Parameters:
5415 
     - orderId
5416 
    """
5417 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5418 
    self.recv_updateOrderOnlyAsPaidToVendor()
5419 
 
5420 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5421 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5422 
    args = updateOrderOnlyAsPaidToVendor_args()
5423 
    args.orderId = orderId
5424 
    args.write(self._oprot)
5425 
    self._oprot.writeMessageEnd()
5426 
    self._oprot.trans.flush()
5427 
 
5428 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5430 
    if mtype == TMessageType.EXCEPTION:
5431 
      x = TApplicationException()
5432 
      x.read(self._iprot)
5433 
      self._iprot.readMessageEnd()
5434 
      raise x
5435 
    result = updateOrderOnlyAsPaidToVendor_result()
5436 
    result.read(self._iprot)
5437 
    self._iprot.readMessageEnd()
5438 
    if result.ex is not None:
5439 
      raise result.ex
5440 
    return
5441 
 
5208 varun.gupt 5442 
  def getRefundedOrdersMarkedPaid(self, ):
5443 
    self.send_getRefundedOrdersMarkedPaid()
5444 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5445 
 
5208 varun.gupt 5446 
  def send_getRefundedOrdersMarkedPaid(self, ):
5447 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5448 
    args = getRefundedOrdersMarkedPaid_args()
5449 
    args.write(self._oprot)
5450 
    self._oprot.writeMessageEnd()
5451 
    self._oprot.trans.flush()
5452 
 
5453 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5455 
    if mtype == TMessageType.EXCEPTION:
5456 
      x = TApplicationException()
5457 
      x.read(self._iprot)
5458 
      self._iprot.readMessageEnd()
5459 
      raise x
5460 
    result = getRefundedOrdersMarkedPaid_result()
5461 
    result.read(self._iprot)
5462 
    self._iprot.readMessageEnd()
5463 
    if result.success is not None:
5464 
      return result.success
5465 
    if result.ex is not None:
5466 
      raise result.ex
5467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5468 
 
5447 anupam.sin 5469 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5470 
    """
5471 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5472 
 
5447 anupam.sin 5473 
 
5474 
    Parameters:
5475 
     - minOrderId
5476 
     - maxOrderId
5477 
    """
5478 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5479 
    return self.recv_getAllVerificationAgents()
5480 
 
5481 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5482 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5483 
    args = getAllVerificationAgents_args()
5484 
    args.minOrderId = minOrderId
5485 
    args.maxOrderId = maxOrderId
5486 
    args.write(self._oprot)
5487 
    self._oprot.writeMessageEnd()
5488 
    self._oprot.trans.flush()
5489 
 
5490 
  def recv_getAllVerificationAgents(self, ):
5491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5492 
    if mtype == TMessageType.EXCEPTION:
5493 
      x = TApplicationException()
5494 
      x.read(self._iprot)
5495 
      self._iprot.readMessageEnd()
5496 
      raise x
5497 
    result = getAllVerificationAgents_result()
5498 
    result.read(self._iprot)
5499 
    self._iprot.readMessageEnd()
5500 
    if result.success is not None:
5501 
      return result.success
5502 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5503 
 
5527 anupam.sin 5504 
  def getAllAttributesForOrderId(self, orderId):
5505 
    """
5506 
    gets all attributes for a given orderId
5447 anupam.sin 5507 
 
5527 anupam.sin 5508 
    Parameters:
5509 
     - orderId
5510 
    """
5511 
    self.send_getAllAttributesForOrderId(orderId)
5512 
    return self.recv_getAllAttributesForOrderId()
5513 
 
5514 
  def send_getAllAttributesForOrderId(self, orderId):
5515 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5516 
    args = getAllAttributesForOrderId_args()
5517 
    args.orderId = orderId
5518 
    args.write(self._oprot)
5519 
    self._oprot.writeMessageEnd()
5520 
    self._oprot.trans.flush()
5521 
 
5522 
  def recv_getAllAttributesForOrderId(self, ):
5523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5524 
    if mtype == TMessageType.EXCEPTION:
5525 
      x = TApplicationException()
5526 
      x.read(self._iprot)
5527 
      self._iprot.readMessageEnd()
5528 
      raise x
5529 
    result = getAllAttributesForOrderId_result()
5530 
    result.read(self._iprot)
5531 
    self._iprot.readMessageEnd()
5532 
    if result.success is not None:
5533 
      return result.success
5534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5535 
 
5676 rajveer 5536 
  def setOrderAttributes(self, orderId, attributes):
5537 
    """
5538 
    sets attributes for an order
5539 
 
5540 
    Parameters:
5541 
     - orderId
5542 
     - attributes
5543 
    """
5544 
    self.send_setOrderAttributes(orderId, attributes)
5545 
    self.recv_setOrderAttributes()
5546 
 
5547 
  def send_setOrderAttributes(self, orderId, attributes):
5548 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5549 
    args = setOrderAttributes_args()
5550 
    args.orderId = orderId
5551 
    args.attributes = attributes
5552 
    args.write(self._oprot)
5553 
    self._oprot.writeMessageEnd()
5554 
    self._oprot.trans.flush()
5555 
 
5556 
  def recv_setOrderAttributes(self, ):
5557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5558 
    if mtype == TMessageType.EXCEPTION:
5559 
      x = TApplicationException()
5560 
      x.read(self._iprot)
5561 
      self._iprot.readMessageEnd()
5562 
      raise x
5563 
    result = setOrderAttributes_result()
5564 
    result.read(self._iprot)
5565 
    self._iprot.readMessageEnd()
5566 
    return
5567 
 
5527 anupam.sin 5568 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5569 
    """
5570 
    sets attributes for all orders in a transaction
5571 
 
5572 
    Parameters:
5573 
     - transactionId
5574 
     - attribute
5575 
    """
5576 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5577 
    self.recv_setOrderAttributeForTransaction()
5578 
 
5579 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5580 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5581 
    args = setOrderAttributeForTransaction_args()
5582 
    args.transactionId = transactionId
5583 
    args.attribute = attribute
5584 
    args.write(self._oprot)
5585 
    self._oprot.writeMessageEnd()
5586 
    self._oprot.trans.flush()
5587 
 
5588 
  def recv_setOrderAttributeForTransaction(self, ):
5589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5590 
    if mtype == TMessageType.EXCEPTION:
5591 
      x = TApplicationException()
5592 
      x.read(self._iprot)
5593 
      self._iprot.readMessageEnd()
5594 
      raise x
5595 
    result = setOrderAttributeForTransaction_result()
5596 
    result.read(self._iprot)
5597 
    self._iprot.readMessageEnd()
5598 
    return
5599 
 
5553 rajveer 5600 
  def getReceivePendingOrders(self, storeId):
5601 
    """
5602 
    Parameters:
5603 
     - storeId
5604 
    """
5605 
    self.send_getReceivePendingOrders(storeId)
5606 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5607 
 
5553 rajveer 5608 
  def send_getReceivePendingOrders(self, storeId):
5609 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5610 
    args = getReceivePendingOrders_args()
5611 
    args.storeId = storeId
5612 
    args.write(self._oprot)
5613 
    self._oprot.writeMessageEnd()
5614 
    self._oprot.trans.flush()
5615 
 
5616 
  def recv_getReceivePendingOrders(self, ):
5617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5618 
    if mtype == TMessageType.EXCEPTION:
5619 
      x = TApplicationException()
5620 
      x.read(self._iprot)
5621 
      self._iprot.readMessageEnd()
5622 
      raise x
5623 
    result = getReceivePendingOrders_result()
5624 
    result.read(self._iprot)
5625 
    self._iprot.readMessageEnd()
5626 
    if result.success is not None:
5627 
      return result.success
5628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5629 
 
5630 
  def getReceivedAtStoreOrders(self, storeId):
5631 
    """
5632 
    Parameters:
5633 
     - storeId
5634 
    """
5635 
    self.send_getReceivedAtStoreOrders(storeId)
5636 
    return self.recv_getReceivedAtStoreOrders()
5637 
 
5638 
  def send_getReceivedAtStoreOrders(self, storeId):
5639 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5640 
    args = getReceivedAtStoreOrders_args()
5641 
    args.storeId = storeId
5642 
    args.write(self._oprot)
5643 
    self._oprot.writeMessageEnd()
5644 
    self._oprot.trans.flush()
5645 
 
5646 
  def recv_getReceivedAtStoreOrders(self, ):
5647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5648 
    if mtype == TMessageType.EXCEPTION:
5649 
      x = TApplicationException()
5650 
      x.read(self._iprot)
5651 
      self._iprot.readMessageEnd()
5652 
      raise x
5653 
    result = getReceivedAtStoreOrders_result()
5654 
    result.read(self._iprot)
5655 
    self._iprot.readMessageEnd()
5656 
    if result.success is not None:
5657 
      return result.success
5658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5659 
 
5713 rajveer 5660 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5661 
    """
5662 
    Parameters:
5663 
     - storeId
5664 
     - fromDate
5665 
     - toDate
5666 
     - onlyCod
5667 
    """
5668 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5669 
    return self.recv_getOrdersCollectionAtStore()
5670 
 
5671 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5672 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5673 
    args = getOrdersCollectionAtStore_args()
5674 
    args.storeId = storeId
5675 
    args.fromDate = fromDate
5676 
    args.toDate = toDate
5677 
    args.onlyCod = onlyCod
5678 
    args.write(self._oprot)
5679 
    self._oprot.writeMessageEnd()
5680 
    self._oprot.trans.flush()
5681 
 
5682 
  def recv_getOrdersCollectionAtStore(self, ):
5683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5684 
    if mtype == TMessageType.EXCEPTION:
5685 
      x = TApplicationException()
5686 
      x.read(self._iprot)
5687 
      self._iprot.readMessageEnd()
5688 
      raise x
5689 
    result = getOrdersCollectionAtStore_result()
5690 
    result.read(self._iprot)
5691 
    self._iprot.readMessageEnd()
5692 
    if result.success is not None:
5693 
      return result.success
5694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5695 
 
5833 rajveer 5696 
  def getOrderAttributeValue(self, orderId, attributeName):
5697 
    """
5698 
    Parameters:
5699 
     - orderId
5700 
     - attributeName
5701 
    """
5702 
    self.send_getOrderAttributeValue(orderId, attributeName)
5703 
    return self.recv_getOrderAttributeValue()
5704 
 
5705 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5706 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5707 
    args = getOrderAttributeValue_args()
5708 
    args.orderId = orderId
5709 
    args.attributeName = attributeName
5710 
    args.write(self._oprot)
5711 
    self._oprot.writeMessageEnd()
5712 
    self._oprot.trans.flush()
5713 
 
5714 
  def recv_getOrderAttributeValue(self, ):
5715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5716 
    if mtype == TMessageType.EXCEPTION:
5717 
      x = TApplicationException()
5718 
      x.read(self._iprot)
5719 
      self._iprot.readMessageEnd()
5720 
      raise x
5721 
    result = getOrderAttributeValue_result()
5722 
    result.read(self._iprot)
5723 
    self._iprot.readMessageEnd()
5724 
    if result.success is not None:
5725 
      return result.success
5726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5727 
 
6019 rajveer 5728 
  def changeJacketNumber(self, orderId, jacketNumber):
5729 
    """
5730 
    Parameters:
5731 
     - orderId
5732 
     - jacketNumber
5733 
    """
5734 
    self.send_changeJacketNumber(orderId, jacketNumber)
5735 
    return self.recv_changeJacketNumber()
5736 
 
5737 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5738 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5739 
    args = changeJacketNumber_args()
5740 
    args.orderId = orderId
5741 
    args.jacketNumber = jacketNumber
5742 
    args.write(self._oprot)
5743 
    self._oprot.writeMessageEnd()
5744 
    self._oprot.trans.flush()
5745 
 
5746 
  def recv_changeJacketNumber(self, ):
5747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5748 
    if mtype == TMessageType.EXCEPTION:
5749 
      x = TApplicationException()
5750 
      x.read(self._iprot)
5751 
      self._iprot.readMessageEnd()
5752 
      raise x
5753 
    result = changeJacketNumber_result()
5754 
    result.read(self._iprot)
5755 
    self._iprot.readMessageEnd()
5756 
    if result.success is not None:
5757 
      return result.success
5758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5759 
 
5760 
  def markOrderAsRtoInTransit(self, orderId):
5761 
    """
5762 
    Parameters:
5763 
     - orderId
5764 
    """
5765 
    self.send_markOrderAsRtoInTransit(orderId)
5766 
    return self.recv_markOrderAsRtoInTransit()
5767 
 
5768 
  def send_markOrderAsRtoInTransit(self, orderId):
5769 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5770 
    args = markOrderAsRtoInTransit_args()
5771 
    args.orderId = orderId
5772 
    args.write(self._oprot)
5773 
    self._oprot.writeMessageEnd()
5774 
    self._oprot.trans.flush()
5775 
 
5776 
  def recv_markOrderAsRtoInTransit(self, ):
5777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5778 
    if mtype == TMessageType.EXCEPTION:
5779 
      x = TApplicationException()
5780 
      x.read(self._iprot)
5781 
      self._iprot.readMessageEnd()
5782 
      raise x
5783 
    result = markOrderAsRtoInTransit_result()
5784 
    result.read(self._iprot)
5785 
    self._iprot.readMessageEnd()
5786 
    if result.success is not None:
5787 
      return result.success
5788 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5789 
 
5593 mandeep.dh 5790 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5791 
    """
5792 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5793 
    invoked while scanning IN of items.
5553 rajveer 5794 
 
5593 mandeep.dh 5795 
    Parameters:
5796 
     - itemId
5797 
     - quantity
5798 
     - fulfilmentWarehouseId
5799 
     - billingWarehouseId
5800 
    """
5801 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5802 
    self.recv_acceptOrderForItem()
5803 
 
5804 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5805 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5806 
    args = acceptOrderForItem_args()
5807 
    args.itemId = itemId
5808 
    args.quantity = quantity
5809 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5810 
    args.billingWarehouseId = billingWarehouseId
5811 
    args.write(self._oprot)
5812 
    self._oprot.writeMessageEnd()
5813 
    self._oprot.trans.flush()
5814 
 
5815 
  def recv_acceptOrderForItem(self, ):
5816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5817 
    if mtype == TMessageType.EXCEPTION:
5818 
      x = TApplicationException()
5819 
      x.read(self._iprot)
5820 
      self._iprot.readMessageEnd()
5821 
      raise x
5822 
    result = acceptOrderForItem_result()
5823 
    result.read(self._iprot)
5824 
    self._iprot.readMessageEnd()
5825 
    return
5826 
 
6000 mandeep.dh 5827 
  def createRechargeOrder(self, rechargeOrder):
5828 
    """
5829 
    Parameters:
5830 
     - rechargeOrder
5831 
    """
5832 
    self.send_createRechargeOrder(rechargeOrder)
5833 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5834 
 
6000 mandeep.dh 5835 
  def send_createRechargeOrder(self, rechargeOrder):
5836 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5837 
    args = createRechargeOrder_args()
5838 
    args.rechargeOrder = rechargeOrder
5839 
    args.write(self._oprot)
5840 
    self._oprot.writeMessageEnd()
5841 
    self._oprot.trans.flush()
5842 
 
5843 
  def recv_createRechargeOrder(self, ):
5844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5845 
    if mtype == TMessageType.EXCEPTION:
5846 
      x = TApplicationException()
5847 
      x.read(self._iprot)
5848 
      self._iprot.readMessageEnd()
5849 
      raise x
5850 
    result = createRechargeOrder_result()
5851 
    result.read(self._iprot)
5852 
    self._iprot.readMessageEnd()
5853 
    if result.success is not None:
5854 
      return result.success
5855 
    if result.ex is not None:
5856 
      raise result.ex
5857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5858 
 
6031 rajveer 5859 
  def getRechargeOrder(self, rechargeRrderId):
5860 
    """
5861 
    Parameters:
5862 
     - rechargeRrderId
5863 
    """
5864 
    self.send_getRechargeOrder(rechargeRrderId)
5865 
    return self.recv_getRechargeOrder()
5866 
 
5867 
  def send_getRechargeOrder(self, rechargeRrderId):
5868 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5869 
    args = getRechargeOrder_args()
5870 
    args.rechargeRrderId = rechargeRrderId
5871 
    args.write(self._oprot)
5872 
    self._oprot.writeMessageEnd()
5873 
    self._oprot.trans.flush()
5874 
 
5875 
  def recv_getRechargeOrder(self, ):
5876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5877 
    if mtype == TMessageType.EXCEPTION:
5878 
      x = TApplicationException()
5879 
      x.read(self._iprot)
5880 
      self._iprot.readMessageEnd()
5881 
      raise x
5882 
    result = getRechargeOrder_result()
5883 
    result.read(self._iprot)
5884 
    self._iprot.readMessageEnd()
5885 
    if result.success is not None:
5886 
      return result.success
5887 
    if result.ex is not None:
5888 
      raise result.ex
5889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5890 
 
5891 
  def getRechargeOrders(self, userId):
5892 
    """
5893 
    Parameters:
5894 
     - userId
5895 
    """
5896 
    self.send_getRechargeOrders(userId)
5897 
    return self.recv_getRechargeOrders()
5898 
 
5899 
  def send_getRechargeOrders(self, userId):
5900 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5901 
    args = getRechargeOrders_args()
5902 
    args.userId = userId
5903 
    args.write(self._oprot)
5904 
    self._oprot.writeMessageEnd()
5905 
    self._oprot.trans.flush()
5906 
 
5907 
  def recv_getRechargeOrders(self, ):
5908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5909 
    if mtype == TMessageType.EXCEPTION:
5910 
      x = TApplicationException()
5911 
      x.read(self._iprot)
5912 
      self._iprot.readMessageEnd()
5913 
      raise x
5914 
    result = getRechargeOrders_result()
5915 
    result.read(self._iprot)
5916 
    self._iprot.readMessageEnd()
5917 
    if result.success is not None:
5918 
      return result.success
5919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5920 
 
6000 mandeep.dh 5921 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5922 
    """
5923 
    Parameters:
5924 
     - rechargeOrderId
5925 
     - rechargeOrderStatus
5926 
    """
5927 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5928 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5929 
 
5930 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5931 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5932 
    args = updateRechargeOrderStatus_args()
5933 
    args.rechargeOrderId = rechargeOrderId
5934 
    args.rechargeOrderStatus = rechargeOrderStatus
5935 
    args.write(self._oprot)
5936 
    self._oprot.writeMessageEnd()
5937 
    self._oprot.trans.flush()
5938 
 
5939 
  def recv_updateRechargeOrderStatus(self, ):
5940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5941 
    if mtype == TMessageType.EXCEPTION:
5942 
      x = TApplicationException()
5943 
      x.read(self._iprot)
5944 
      self._iprot.readMessageEnd()
5945 
      raise x
5946 
    result = updateRechargeOrderStatus_result()
5947 
    result.read(self._iprot)
5948 
    self._iprot.readMessageEnd()
6031 rajveer 5949 
    if result.success is not None:
5950 
      return result.success
6000 mandeep.dh 5951 
    if result.ex is not None:
5952 
      raise result.ex
6031 rajveer 5953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5954 
 
6031 rajveer 5955 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5956 
    """
5957 
    Parameters:
6031 rajveer 5958 
     - rechargeOrderId
6000 mandeep.dh 5959 
    """
6031 rajveer 5960 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5961 
    return self.recv_activateRechargeTxn()
5962 
 
6031 rajveer 5963 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5964 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5965 
    args = activateRechargeTxn_args()
6031 rajveer 5966 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5967 
    args.write(self._oprot)
5968 
    self._oprot.writeMessageEnd()
5969 
    self._oprot.trans.flush()
5970 
 
5971 
  def recv_activateRechargeTxn(self, ):
5972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5973 
    if mtype == TMessageType.EXCEPTION:
5974 
      x = TApplicationException()
5975 
      x.read(self._iprot)
5976 
      self._iprot.readMessageEnd()
5977 
      raise x
5978 
    result = activateRechargeTxn_result()
5979 
    result.read(self._iprot)
5980 
    self._iprot.readMessageEnd()
5981 
    if result.success is not None:
5982 
      return result.success
5983 
    if result.ex is not None:
5984 
      raise result.ex
5985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5986 
 
6031 rajveer 5987 
  def getUserWallet(self, userId):
6000 mandeep.dh 5988 
    """
5989 
    Parameters:
6031 rajveer 5990 
     - userId
6000 mandeep.dh 5991 
    """
6031 rajveer 5992 
    self.send_getUserWallet(userId)
5993 
    return self.recv_getUserWallet()
6000 mandeep.dh 5994 
 
6031 rajveer 5995 
  def send_getUserWallet(self, userId):
5996 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
5997 
    args = getUserWallet_args()
5998 
    args.userId = userId
6000 mandeep.dh 5999 
    args.write(self._oprot)
6000 
    self._oprot.writeMessageEnd()
6001 
    self._oprot.trans.flush()
6002 
 
6031 rajveer 6003 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6005 
    if mtype == TMessageType.EXCEPTION:
6006 
      x = TApplicationException()
6007 
      x.read(self._iprot)
6008 
      self._iprot.readMessageEnd()
6009 
      raise x
6031 rajveer 6010 
    result = getUserWallet_result()
6000 mandeep.dh 6011 
    result.read(self._iprot)
6012 
    self._iprot.readMessageEnd()
6013 
    if result.success is not None:
6014 
      return result.success
6031 rajveer 6015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6016 
 
6031 rajveer 6017 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6018 
    """
6019 
    Parameters:
6031 rajveer 6020 
     - userId
6000 mandeep.dh 6021 
    """
6031 rajveer 6022 
    self.send_getUserWalletHistory(userId)
6023 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6024 
 
6031 rajveer 6025 
  def send_getUserWalletHistory(self, userId):
6026 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6027 
    args = getUserWalletHistory_args()
6028 
    args.userId = userId
6000 mandeep.dh 6029 
    args.write(self._oprot)
6030 
    self._oprot.writeMessageEnd()
6031 
    self._oprot.trans.flush()
6032 
 
6031 rajveer 6033 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6035 
    if mtype == TMessageType.EXCEPTION:
6036 
      x = TApplicationException()
6037 
      x.read(self._iprot)
6038 
      self._iprot.readMessageEnd()
6039 
      raise x
6031 rajveer 6040 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6041 
    result.read(self._iprot)
6042 
    self._iprot.readMessageEnd()
6043 
    if result.success is not None:
6044 
      return result.success
6031 rajveer 6045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6046 
 
6050 anupam.sin 6047 
  def getRechargeOrdersForTransaction(self, txnId):
6048 
    """
6049 
    Returns a recharge order for a given transactionId
6050 
 
6051 
    Parameters:
6052 
     - txnId
6053 
    """
6054 
    self.send_getRechargeOrdersForTransaction(txnId)
6055 
    return self.recv_getRechargeOrdersForTransaction()
6056 
 
6057 
  def send_getRechargeOrdersForTransaction(self, txnId):
6058 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6059 
    args = getRechargeOrdersForTransaction_args()
6060 
    args.txnId = txnId
6061 
    args.write(self._oprot)
6062 
    self._oprot.writeMessageEnd()
6063 
    self._oprot.trans.flush()
6064 
 
6065 
  def recv_getRechargeOrdersForTransaction(self, ):
6066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6067 
    if mtype == TMessageType.EXCEPTION:
6068 
      x = TApplicationException()
6069 
      x.read(self._iprot)
6070 
      self._iprot.readMessageEnd()
6071 
      raise x
6072 
    result = getRechargeOrdersForTransaction_result()
6073 
    result.read(self._iprot)
6074 
    self._iprot.readMessageEnd()
6075 
    if result.success is not None:
6076 
      return result.success
6077 
    if result.ex is not None:
6078 
      raise result.ex
6079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6080 
 
6048 rajveer 6081 
  def getServiceProviders(self, rechargeType):
6082 
    """
6083 
    Parameters:
6084 
     - rechargeType
6085 
    """
6086 
    self.send_getServiceProviders(rechargeType)
6087 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6088 
 
6048 rajveer 6089 
  def send_getServiceProviders(self, rechargeType):
6090 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6091 
    args = getServiceProviders_args()
6092 
    args.rechargeType = rechargeType
6093 
    args.write(self._oprot)
6094 
    self._oprot.writeMessageEnd()
6095 
    self._oprot.trans.flush()
6096 
 
6097 
  def recv_getServiceProviders(self, ):
6098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6099 
    if mtype == TMessageType.EXCEPTION:
6100 
      x = TApplicationException()
6101 
      x.read(self._iprot)
6102 
      self._iprot.readMessageEnd()
6103 
      raise x
6104 
    result = getServiceProviders_result()
6105 
    result.read(self._iprot)
6106 
    self._iprot.readMessageEnd()
6107 
    if result.success is not None:
6108 
      return result.success
6109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6110 
 
6049 rajveer 6111 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6112 
    """
6113 
    Parameters:
6049 rajveer 6114 
     - rechargeType
6048 rajveer 6115 
     - deviceNumber
6116 
    """
6049 rajveer 6117 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6118 
    return self.recv_getServiceProviderForDevice()
6119 
 
6049 rajveer 6120 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6121 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6122 
    args = getServiceProviderForDevice_args()
6049 rajveer 6123 
    args.rechargeType = rechargeType
6048 rajveer 6124 
    args.deviceNumber = deviceNumber
6125 
    args.write(self._oprot)
6126 
    self._oprot.writeMessageEnd()
6127 
    self._oprot.trans.flush()
6128 
 
6129 
  def recv_getServiceProviderForDevice(self, ):
6130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6131 
    if mtype == TMessageType.EXCEPTION:
6132 
      x = TApplicationException()
6133 
      x.read(self._iprot)
6134 
      self._iprot.readMessageEnd()
6135 
      raise x
6136 
    result = getServiceProviderForDevice_result()
6137 
    result.read(self._iprot)
6138 
    self._iprot.readMessageEnd()
6139 
    if result.success is not None:
6140 
      return result.success
6141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6142 
 
6094 rajveer 6143 
  def getRechargeOrdersForDevice(self, deviceNumber):
6144 
    """
6145 
    Parameters:
6146 
     - deviceNumber
6147 
    """
6148 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6149 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6150 
 
6094 rajveer 6151 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6152 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6153 
    args = getRechargeOrdersForDevice_args()
6154 
    args.deviceNumber = deviceNumber
6155 
    args.write(self._oprot)
6156 
    self._oprot.writeMessageEnd()
6157 
    self._oprot.trans.flush()
6158 
 
6159 
  def recv_getRechargeOrdersForDevice(self, ):
6160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6161 
    if mtype == TMessageType.EXCEPTION:
6162 
      x = TApplicationException()
6163 
      x.read(self._iprot)
6164 
      self._iprot.readMessageEnd()
6165 
      raise x
6166 
    result = getRechargeOrdersForDevice_result()
6167 
    result.read(self._iprot)
6168 
    self._iprot.readMessageEnd()
6169 
    if result.success is not None:
6170 
      return result.success
6171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6172 
 
6173 
  def addAmountToWallet(self, userId, orderId, amount):
6174 
    """
6175 
    Parameters:
6176 
     - userId
6177 
     - orderId
6178 
     - amount
6179 
    """
6180 
    self.send_addAmountToWallet(userId, orderId, amount)
6181 
    self.recv_addAmountToWallet()
6182 
 
6183 
  def send_addAmountToWallet(self, userId, orderId, amount):
6184 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6185 
    args = addAmountToWallet_args()
6186 
    args.userId = userId
6187 
    args.orderId = orderId
6188 
    args.amount = amount
6189 
    args.write(self._oprot)
6190 
    self._oprot.writeMessageEnd()
6191 
    self._oprot.trans.flush()
6192 
 
6193 
  def recv_addAmountToWallet(self, ):
6194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6195 
    if mtype == TMessageType.EXCEPTION:
6196 
      x = TApplicationException()
6197 
      x.read(self._iprot)
6198 
      self._iprot.readMessageEnd()
6199 
      raise x
6200 
    result = addAmountToWallet_result()
6201 
    result.read(self._iprot)
6202 
    self._iprot.readMessageEnd()
6203 
    return
6204 
 
6154 rajveer 6205 
  def getRechargeOrdersForStatus(self, status):
6206 
    """
6207 
    Parameters:
6208 
     - status
6209 
    """
6210 
    self.send_getRechargeOrdersForStatus(status)
6211 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6212 
 
6154 rajveer 6213 
  def send_getRechargeOrdersForStatus(self, status):
6214 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6215 
    args = getRechargeOrdersForStatus_args()
6216 
    args.status = status
6217 
    args.write(self._oprot)
6218 
    self._oprot.writeMessageEnd()
6219 
    self._oprot.trans.flush()
6220 
 
6221 
  def recv_getRechargeOrdersForStatus(self, ):
6222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6223 
    if mtype == TMessageType.EXCEPTION:
6224 
      x = TApplicationException()
6225 
      x.read(self._iprot)
6226 
      self._iprot.readMessageEnd()
6227 
      raise x
6228 
    result = getRechargeOrdersForStatus_result()
6229 
    result.read(self._iprot)
6230 
    self._iprot.readMessageEnd()
6231 
    if result.success is not None:
6232 
      return result.success
6233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6234 
 
6235 
 
3376 rajveer 6236 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6237 
  def __init__(self, handler):
3376 rajveer 6238 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6239 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6240 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6241 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6242 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6243 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6244 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6245 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6246 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6247 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6248 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6249 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6250 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6251 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6252 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6253 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6254 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6255 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6256 
    self._processMap["createOrder"] = Processor.process_createOrder
6257 
    self._processMap["getOrder"] = Processor.process_getOrder
6258 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6259 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6260 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6261 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6262 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6263 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6264 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6265 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6266 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6267 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6268 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6269 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6270 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6271 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6272 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6273 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6274 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6275 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6276 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6277 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6278 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6279 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6280 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6281 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6282 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6283 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6284 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6285 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6286 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6287 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6288 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6289 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6290 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6291 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6292 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6293 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6294 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6295 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6296 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6297 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6298 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6299 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6300 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6301 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6302 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6303 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6304 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6305 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6306 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6307 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6308 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6309 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6310 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6311 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6312 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6313 
    self._processMap["changeItem"] = Processor.process_changeItem
6314 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6315 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6316 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6317 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6318 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6319 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6320 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6321 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6322 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6323 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6324 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6325 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6326 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6327 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6328 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6329 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6330 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6331 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6332 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6333 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6334 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6335 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6336 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6337 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6338 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6339 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6340 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6341 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6342 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6343 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6344 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6345 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6346 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6347 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6348 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6349 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6350 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6351 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6352 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6353 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6354 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6355 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6356 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6357 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6358 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6359 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6360 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6361 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6362 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6363 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6364 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6365 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6366 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6367 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6368 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6369 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6370 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6371 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6372 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6373 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6374 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6375 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6094 rajveer 6376 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6377 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6154 rajveer 6378 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
94 ashish 6379 
 
6380 
  def process(self, iprot, oprot):
6381 
    (name, type, seqid) = iprot.readMessageBegin()
6382 
    if name not in self._processMap:
6383 
      iprot.skip(TType.STRUCT)
6384 
      iprot.readMessageEnd()
6385 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6386 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6387 
      x.write(oprot)
6388 
      oprot.writeMessageEnd()
6389 
      oprot.trans.flush()
6390 
      return
6391 
    else:
6392 
      self._processMap[name](self, seqid, iprot, oprot)
6393 
    return True
6394 
 
6395 
  def process_createTransaction(self, seqid, iprot, oprot):
6396 
    args = createTransaction_args()
6397 
    args.read(iprot)
6398 
    iprot.readMessageEnd()
6399 
    result = createTransaction_result()
6400 
    try:
132 ashish 6401 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6402 
    except TransactionServiceException, ex:
6403 
      result.ex = ex
6404 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6405 
    result.write(oprot)
6406 
    oprot.writeMessageEnd()
6407 
    oprot.trans.flush()
6408 
 
6409 
  def process_getTransaction(self, seqid, iprot, oprot):
6410 
    args = getTransaction_args()
6411 
    args.read(iprot)
6412 
    iprot.readMessageEnd()
6413 
    result = getTransaction_result()
6414 
    try:
6415 
      result.success = self._handler.getTransaction(args.id)
6416 
    except TransactionServiceException, ex:
6417 
      result.ex = ex
6418 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6419 
    result.write(oprot)
6420 
    oprot.writeMessageEnd()
6421 
    oprot.trans.flush()
6422 
 
6423 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6424 
    args = getTransactionsForCustomer_args()
6425 
    args.read(iprot)
6426 
    iprot.readMessageEnd()
6427 
    result = getTransactionsForCustomer_result()
6428 
    try:
6429 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6430 
    except TransactionServiceException, ex:
6431 
      result.ex = ex
6432 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6433 
    result.write(oprot)
6434 
    oprot.writeMessageEnd()
6435 
    oprot.trans.flush()
6436 
 
132 ashish 6437 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6438 
    args = getTransactionsForShoppingCartId_args()
6439 
    args.read(iprot)
6440 
    iprot.readMessageEnd()
6441 
    result = getTransactionsForShoppingCartId_result()
6442 
    try:
6443 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6444 
    except TransactionServiceException, ex:
6445 
      result.ex = ex
6446 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6447 
    result.write(oprot)
6448 
    oprot.writeMessageEnd()
6449 
    oprot.trans.flush()
6450 
 
94 ashish 6451 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6452 
    args = getTransactionStatus_args()
6453 
    args.read(iprot)
6454 
    iprot.readMessageEnd()
6455 
    result = getTransactionStatus_result()
6456 
    try:
6457 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6458 
    except TransactionServiceException, ex:
6459 
      result.ex = ex
6460 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6461 
    result.write(oprot)
6462 
    oprot.writeMessageEnd()
6463 
    oprot.trans.flush()
6464 
 
6465 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6466 
    args = changeTransactionStatus_args()
6467 
    args.read(iprot)
6468 
    iprot.readMessageEnd()
6469 
    result = changeTransactionStatus_result()
6470 
    try:
5527 anupam.sin 6471 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6472 
    except TransactionServiceException, ex:
6473 
      result.ex = ex
6474 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6475 
    result.write(oprot)
6476 
    oprot.writeMessageEnd()
6477 
    oprot.trans.flush()
6478 
 
1398 varun.gupt 6479 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6480 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6481 
    args.read(iprot)
6482 
    iprot.readMessageEnd()
1398 varun.gupt 6483 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6484 
    try:
1398 varun.gupt 6485 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6486 
    except TransactionServiceException, ex:
6487 
      result.ex = ex
1398 varun.gupt 6488 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6489 
    result.write(oprot)
6490 
    oprot.writeMessageEnd()
6491 
    oprot.trans.flush()
6492 
 
483 rajveer 6493 
  def process_getAllOrders(self, seqid, iprot, oprot):
6494 
    args = getAllOrders_args()
94 ashish 6495 
    args.read(iprot)
6496 
    iprot.readMessageEnd()
483 rajveer 6497 
    result = getAllOrders_result()
94 ashish 6498 
    try:
4801 anupam.sin 6499 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6500 
    except TransactionServiceException, ex:
6501 
      result.ex = ex
483 rajveer 6502 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6503 
    result.write(oprot)
6504 
    oprot.writeMessageEnd()
6505 
    oprot.trans.flush()
6506 
 
4133 chandransh 6507 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6508 
    args = getOrdersInBatch_args()
6509 
    args.read(iprot)
6510 
    iprot.readMessageEnd()
6511 
    result = getOrdersInBatch_result()
6512 
    try:
6513 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6514 
    except TransactionServiceException, ex:
6515 
      result.ex = ex
6516 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6517 
    result.write(oprot)
6518 
    oprot.writeMessageEnd()
6519 
    oprot.trans.flush()
6520 
 
6521 
  def process_getOrderCount(self, seqid, iprot, oprot):
6522 
    args = getOrderCount_args()
6523 
    args.read(iprot)
6524 
    iprot.readMessageEnd()
6525 
    result = getOrderCount_result()
6526 
    try:
6527 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6528 
    except TransactionServiceException, ex:
6529 
      result.ex = ex
6530 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6531 
    result.write(oprot)
6532 
    oprot.writeMessageEnd()
6533 
    oprot.trans.flush()
6534 
 
999 varun.gupt 6535 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6536 
    args = getOrdersByBillingDate_args()
6537 
    args.read(iprot)
6538 
    iprot.readMessageEnd()
6539 
    result = getOrdersByBillingDate_result()
6540 
    try:
6541 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6542 
    except TransactionServiceException, ex:
6543 
      result.ex = ex
6544 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6545 
    result.write(oprot)
6546 
    oprot.writeMessageEnd()
6547 
    oprot.trans.flush()
6548 
 
3427 chandransh 6549 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6550 
    args = getOrdersByShippingDate_args()
6551 
    args.read(iprot)
6552 
    iprot.readMessageEnd()
6553 
    result = getOrdersByShippingDate_result()
6554 
    try:
3451 chandransh 6555 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6556 
    except TransactionServiceException, ex:
6557 
      result.ex = ex
6558 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6559 
    result.write(oprot)
6560 
    oprot.writeMessageEnd()
6561 
    oprot.trans.flush()
6562 
 
1382 varun.gupt 6563 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6564 
    args = getReturnableOrdersForCustomer_args()
6565 
    args.read(iprot)
6566 
    iprot.readMessageEnd()
6567 
    result = getReturnableOrdersForCustomer_result()
6568 
    try:
6569 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6570 
    except TransactionServiceException, ex:
6571 
      result.ex = ex
6572 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6573 
    result.write(oprot)
6574 
    oprot.writeMessageEnd()
6575 
    oprot.trans.flush()
6576 
 
6577 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6578 
    args = getCancellableOrdersForCustomer_args()
6579 
    args.read(iprot)
6580 
    iprot.readMessageEnd()
6581 
    result = getCancellableOrdersForCustomer_result()
6582 
    try:
6583 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6584 
    except TransactionServiceException, ex:
6585 
      result.ex = ex
6586 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6587 
    result.write(oprot)
6588 
    oprot.writeMessageEnd()
6589 
    oprot.trans.flush()
6590 
 
483 rajveer 6591 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6592 
    args = changeOrderStatus_args()
94 ashish 6593 
    args.read(iprot)
6594 
    iprot.readMessageEnd()
483 rajveer 6595 
    result = changeOrderStatus_result()
94 ashish 6596 
    try:
483 rajveer 6597 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6598 
    except TransactionServiceException, ex:
6599 
      result.ex = ex
483 rajveer 6600 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6601 
    result.write(oprot)
6602 
    oprot.writeMessageEnd()
6603 
    oprot.trans.flush()
6604 
 
483 rajveer 6605 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6606 
    args = getOrdersForTransaction_args()
94 ashish 6607 
    args.read(iprot)
6608 
    iprot.readMessageEnd()
483 rajveer 6609 
    result = getOrdersForTransaction_result()
94 ashish 6610 
    try:
1528 ankur.sing 6611 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6612 
    except TransactionServiceException, ex:
6613 
      result.ex = ex
483 rajveer 6614 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6615 
    result.write(oprot)
6616 
    oprot.writeMessageEnd()
6617 
    oprot.trans.flush()
6618 
 
483 rajveer 6619 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6620 
    args = getOrdersForCustomer_args()
94 ashish 6621 
    args.read(iprot)
6622 
    iprot.readMessageEnd()
483 rajveer 6623 
    result = getOrdersForCustomer_result()
94 ashish 6624 
    try:
3014 chandransh 6625 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6626 
    except TransactionServiceException, ex:
6627 
      result.ex = ex
483 rajveer 6628 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6629 
    result.write(oprot)
6630 
    oprot.writeMessageEnd()
6631 
    oprot.trans.flush()
6632 
 
483 rajveer 6633 
  def process_createOrder(self, seqid, iprot, oprot):
6634 
    args = createOrder_args()
94 ashish 6635 
    args.read(iprot)
6636 
    iprot.readMessageEnd()
483 rajveer 6637 
    result = createOrder_result()
94 ashish 6638 
    try:
483 rajveer 6639 
      result.success = self._handler.createOrder(args.order)
94 ashish 6640 
    except TransactionServiceException, ex:
6641 
      result.ex = ex
483 rajveer 6642 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6643 
    result.write(oprot)
6644 
    oprot.writeMessageEnd()
6645 
    oprot.trans.flush()
6646 
 
483 rajveer 6647 
  def process_getOrder(self, seqid, iprot, oprot):
6648 
    args = getOrder_args()
94 ashish 6649 
    args.read(iprot)
6650 
    iprot.readMessageEnd()
483 rajveer 6651 
    result = getOrder_result()
94 ashish 6652 
    try:
483 rajveer 6653 
      result.success = self._handler.getOrder(args.id)
94 ashish 6654 
    except TransactionServiceException, ex:
6655 
      result.ex = ex
483 rajveer 6656 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6657 
    result.write(oprot)
6658 
    oprot.writeMessageEnd()
6659 
    oprot.trans.flush()
6660 
 
483 rajveer 6661 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6662 
    args = getLineItemsForOrder_args()
94 ashish 6663 
    args.read(iprot)
6664 
    iprot.readMessageEnd()
483 rajveer 6665 
    result = getLineItemsForOrder_result()
94 ashish 6666 
    try:
483 rajveer 6667 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6668 
    except TransactionServiceException, ex:
6669 
      result.ex = ex
483 rajveer 6670 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6671 
    result.write(oprot)
6672 
    oprot.writeMessageEnd()
6673 
    oprot.trans.flush()
6674 
 
4999 phani.kuma 6675 
  def process_getOrderList(self, seqid, iprot, oprot):
6676 
    args = getOrderList_args()
6677 
    args.read(iprot)
6678 
    iprot.readMessageEnd()
6679 
    result = getOrderList_result()
6680 
    result.success = self._handler.getOrderList(args.order_ids)
6681 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6682 
    result.write(oprot)
6683 
    oprot.writeMessageEnd()
6684 
    oprot.trans.flush()
6685 
 
5386 phani.kuma 6686 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6687 
    args = getOrderListForVendor_args()
6688 
    args.read(iprot)
6689 
    iprot.readMessageEnd()
6690 
    result = getOrderListForVendor_result()
6691 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6692 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6693 
    result.write(oprot)
6694 
    oprot.writeMessageEnd()
6695 
    oprot.trans.flush()
6696 
 
1528 ankur.sing 6697 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6698 
    args = getOrderForCustomer_args()
6699 
    args.read(iprot)
6700 
    iprot.readMessageEnd()
6701 
    result = getOrderForCustomer_result()
6702 
    try:
6703 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6704 
    except TransactionServiceException, ex:
6705 
      result.ex = ex
6706 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6707 
    result.write(oprot)
6708 
    oprot.writeMessageEnd()
6709 
    oprot.trans.flush()
6710 
 
3064 chandransh 6711 
  def process_getAlerts(self, seqid, iprot, oprot):
6712 
    args = getAlerts_args()
6713 
    args.read(iprot)
6714 
    iprot.readMessageEnd()
6715 
    result = getAlerts_result()
4444 rajveer 6716 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6717 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6718 
    result.write(oprot)
6719 
    oprot.writeMessageEnd()
6720 
    oprot.trans.flush()
6721 
 
4394 rajveer 6722 
  def process_addAlert(self, seqid, iprot, oprot):
6723 
    args = addAlert_args()
3064 chandransh 6724 
    args.read(iprot)
6725 
    iprot.readMessageEnd()
4394 rajveer 6726 
    result = addAlert_result()
4444 rajveer 6727 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6728 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6729 
    result.write(oprot)
6730 
    oprot.writeMessageEnd()
6731 
    oprot.trans.flush()
6732 
 
4444 rajveer 6733 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6734 
    args = markAlertsAsSeen_args()
6735 
    args.read(iprot)
6736 
    iprot.readMessageEnd()
6737 
    result = markAlertsAsSeen_result()
6738 
    self._handler.markAlertsAsSeen(args.warehouseId)
6739 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
6743 
 
3064 chandransh 6744 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6745 
    args = getValidOrderCount_args()
6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
6748 
    result = getValidOrderCount_result()
6749 
    result.success = self._handler.getValidOrderCount()
6750 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6751 
    result.write(oprot)
6752 
    oprot.writeMessageEnd()
6753 
    oprot.trans.flush()
6754 
 
6755 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6756 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6757 
    args.read(iprot)
6758 
    iprot.readMessageEnd()
6759 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6760 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6761 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6762 
    result.write(oprot)
6763 
    oprot.writeMessageEnd()
6764 
    oprot.trans.flush()
6765 
 
6766 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6767 
    args = getValidOrdersAmountRange_args()
6768 
    args.read(iprot)
6769 
    iprot.readMessageEnd()
6770 
    result = getValidOrdersAmountRange_result()
6771 
    result.success = self._handler.getValidOrdersAmountRange()
6772 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6773 
    result.write(oprot)
6774 
    oprot.writeMessageEnd()
6775 
    oprot.trans.flush()
6776 
 
6777 
  def process_getValidOrders(self, seqid, iprot, oprot):
6778 
    args = getValidOrders_args()
6779 
    args.read(iprot)
6780 
    iprot.readMessageEnd()
6781 
    result = getValidOrders_result()
5874 rajveer 6782 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6783 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6784 
    result.write(oprot)
6785 
    oprot.writeMessageEnd()
6786 
    oprot.trans.flush()
6787 
 
1220 chandransh 6788 
  def process_batchOrders(self, seqid, iprot, oprot):
6789 
    args = batchOrders_args()
6790 
    args.read(iprot)
6791 
    iprot.readMessageEnd()
6792 
    result = batchOrders_result()
6793 
    try:
6794 
      result.success = self._handler.batchOrders(args.warehouseId)
6795 
    except TransactionServiceException, ex:
6796 
      result.ex = ex
6797 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6798 
    result.write(oprot)
6799 
    oprot.writeMessageEnd()
6800 
    oprot.trans.flush()
6801 
 
1208 chandransh 6802 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6803 
    args = markOrderAsOutOfStock_args()
6804 
    args.read(iprot)
6805 
    iprot.readMessageEnd()
6806 
    result = markOrderAsOutOfStock_result()
6807 
    try:
6808 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6809 
    except TransactionServiceException, ex:
6810 
      result.ex = ex
6811 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6812 
    result.write(oprot)
6813 
    oprot.writeMessageEnd()
6814 
    oprot.trans.flush()
6815 
 
3064 chandransh 6816 
  def process_verifyOrder(self, seqid, iprot, oprot):
6817 
    args = verifyOrder_args()
759 chandransh 6818 
    args.read(iprot)
6819 
    iprot.readMessageEnd()
3064 chandransh 6820 
    result = verifyOrder_result()
759 chandransh 6821 
    try:
3064 chandransh 6822 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6823 
    except TransactionServiceException, ex:
6824 
      result.ex = ex
3064 chandransh 6825 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6826 
    result.write(oprot)
6827 
    oprot.writeMessageEnd()
6828 
    oprot.trans.flush()
6829 
 
3064 chandransh 6830 
  def process_acceptOrder(self, seqid, iprot, oprot):
6831 
    args = acceptOrder_args()
1113 chandransh 6832 
    args.read(iprot)
6833 
    iprot.readMessageEnd()
3064 chandransh 6834 
    result = acceptOrder_result()
1113 chandransh 6835 
    try:
3064 chandransh 6836 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6837 
    except TransactionServiceException, ex:
6838 
      result.ex = ex
3064 chandransh 6839 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6840 
    result.write(oprot)
6841 
    oprot.writeMessageEnd()
6842 
    oprot.trans.flush()
6843 
 
3064 chandransh 6844 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6845 
    args = addBillingDetails_args()
1135 chandransh 6846 
    args.read(iprot)
6847 
    iprot.readMessageEnd()
3064 chandransh 6848 
    result = addBillingDetails_result()
1135 chandransh 6849 
    try:
5110 mandeep.dh 6850 
      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 6851 
    except TransactionServiceException, ex:
6852 
      result.ex = ex
3064 chandransh 6853 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6854 
    result.write(oprot)
6855 
    oprot.writeMessageEnd()
6856 
    oprot.trans.flush()
6857 
 
4579 rajveer 6858 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6859 
    args = addInvoiceNumber_args()
6860 
    args.read(iprot)
6861 
    iprot.readMessageEnd()
6862 
    result = addInvoiceNumber_result()
6863 
    try:
4763 rajveer 6864 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6865 
    except TransactionServiceException, ex:
6866 
      result.ex = ex
6867 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6868 
    result.write(oprot)
6869 
    oprot.writeMessageEnd()
6870 
    oprot.trans.flush()
6871 
 
4410 rajveer 6872 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6873 
    args = markOrdersAsShippedFromWarehouse_args()
6874 
    args.read(iprot)
6875 
    iprot.readMessageEnd()
6876 
    result = markOrdersAsShippedFromWarehouse_result()
6877 
    try:
4789 rajveer 6878 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6879 
    except TransactionServiceException, ex:
6880 
      result.ex = ex
6881 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6882 
    result.write(oprot)
6883 
    oprot.writeMessageEnd()
6884 
    oprot.trans.flush()
6885 
 
5676 rajveer 6886 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6887 
    args = markOrdersAsReturnedFromStore_args()
6888 
    args.read(iprot)
6889 
    iprot.readMessageEnd()
6890 
    result = markOrdersAsReturnedFromStore_result()
6891 
    try:
5713 rajveer 6892 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6893 
    except TransactionServiceException, ex:
6894 
      result.ex = ex
6895 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6896 
    result.write(oprot)
6897 
    oprot.writeMessageEnd()
6898 
    oprot.trans.flush()
6899 
 
3064 chandransh 6900 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6901 
    args = markOrdersAsPickedUp_args()
304 ashish 6902 
    args.read(iprot)
6903 
    iprot.readMessageEnd()
3064 chandransh 6904 
    result = markOrdersAsPickedUp_result()
6905 
    try:
4910 phani.kuma 6906 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6907 
    except TransactionServiceException, ex:
6908 
      result.ex = ex
6909 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6910 
    result.write(oprot)
6911 
    oprot.writeMessageEnd()
6912 
    oprot.trans.flush()
94 ashish 6913 
 
4910 phani.kuma 6914 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6915 
    args = getOrdersNotPickedUp_args()
6916 
    args.read(iprot)
6917 
    iprot.readMessageEnd()
6918 
    result = getOrdersNotPickedUp_result()
6919 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6920 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6921 
    result.write(oprot)
6922 
    oprot.writeMessageEnd()
6923 
    oprot.trans.flush()
6924 
 
3064 chandransh 6925 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6926 
    args = markOrdersAsDelivered_args()
304 ashish 6927 
    args.read(iprot)
6928 
    iprot.readMessageEnd()
3064 chandransh 6929 
    result = markOrdersAsDelivered_result()
6930 
    try:
6931 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6932 
    except TransactionServiceException, ex:
6933 
      result.ex = ex
6934 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
6938 
 
4910 phani.kuma 6939 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6940 
    args = markAsRTOrders_args()
1596 ankur.sing 6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
4910 phani.kuma 6943 
    result = markAsRTOrders_result()
3064 chandransh 6944 
    try:
4910 phani.kuma 6945 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6946 
    except TransactionServiceException, ex:
6947 
      result.ex = ex
4910 phani.kuma 6948 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6949 
    result.write(oprot)
6950 
    oprot.writeMessageEnd()
6951 
    oprot.trans.flush()
304 ashish 6952 
 
4910 phani.kuma 6953 
  def process_getRTOrders(self, seqid, iprot, oprot):
6954 
    args = getRTOrders_args()
6955 
    args.read(iprot)
6956 
    iprot.readMessageEnd()
6957 
    result = getRTOrders_result()
6958 
    result.success = self._handler.getRTOrders(args.providerId)
6959 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6960 
    result.write(oprot)
6961 
    oprot.writeMessageEnd()
6962 
    oprot.trans.flush()
6963 
 
3064 chandransh 6964 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6965 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6966 
    args.read(iprot)
6967 
    iprot.readMessageEnd()
3064 chandransh 6968 
    result = updateNonDeliveryReason_result()
6969 
    try:
4910 phani.kuma 6970 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6971 
    except TransactionServiceException, ex:
6972 
      result.ex = ex
6973 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6974 
    result.write(oprot)
6975 
    oprot.writeMessageEnd()
6976 
    oprot.trans.flush()
1596 ankur.sing 6977 
 
4910 phani.kuma 6978 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6979 
    args = getNonDeliveredOrdersbyCourier_args()
6980 
    args.read(iprot)
6981 
    iprot.readMessageEnd()
6982 
    result = getNonDeliveredOrdersbyCourier_result()
6983 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6984 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6985 
    result.write(oprot)
6986 
    oprot.writeMessageEnd()
6987 
    oprot.trans.flush()
6988 
 
6989 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6990 
    args = markOrdersAsLocalConnected_args()
6991 
    args.read(iprot)
6992 
    iprot.readMessageEnd()
6993 
    result = markOrdersAsLocalConnected_result()
6994 
    try:
6995 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6996 
    except TransactionServiceException, ex:
6997 
      result.ex = ex
6998 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6999 
    result.write(oprot)
7000 
    oprot.writeMessageEnd()
7001 
    oprot.trans.flush()
7002 
 
7003 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7004 
    args = getOrdersNotLocalConnected_args()
7005 
    args.read(iprot)
7006 
    iprot.readMessageEnd()
7007 
    result = getOrdersNotLocalConnected_result()
7008 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7009 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7010 
    result.write(oprot)
7011 
    oprot.writeMessageEnd()
7012 
    oprot.trans.flush()
7013 
 
7014 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7015 
    args = markOrdersAsDestinationCityReached_args()
7016 
    args.read(iprot)
7017 
    iprot.readMessageEnd()
7018 
    result = markOrdersAsDestinationCityReached_result()
7019 
    try:
7020 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7021 
    except TransactionServiceException, ex:
7022 
      result.ex = ex
7023 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7024 
    result.write(oprot)
7025 
    oprot.writeMessageEnd()
7026 
    oprot.trans.flush()
7027 
 
7028 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7029 
    args = markOrdersAsFirstDeliveryAttempted_args()
7030 
    args.read(iprot)
7031 
    iprot.readMessageEnd()
7032 
    result = markOrdersAsFirstDeliveryAttempted_result()
7033 
    try:
7034 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7035 
    except TransactionServiceException, ex:
7036 
      result.ex = ex
7037 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7038 
    result.write(oprot)
7039 
    oprot.writeMessageEnd()
7040 
    oprot.trans.flush()
7041 
 
3064 chandransh 7042 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7043 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7044 
    args.read(iprot)
7045 
    iprot.readMessageEnd()
3064 chandransh 7046 
    result = getUndeliveredOrders_result()
7047 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7048 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7049 
    result.write(oprot)
7050 
    oprot.writeMessageEnd()
7051 
    oprot.trans.flush()
7052 
 
4783 phani.kuma 7053 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7054 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7055 
    args.read(iprot)
7056 
    iprot.readMessageEnd()
7057 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7058 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7059 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
7063 
 
2536 chandransh 7064 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7065 
    args = toggleDOAFlag_args()
7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
7068 
    result = toggleDOAFlag_result()
7069 
    try:
7070 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7071 
    except TransactionServiceException, ex:
7072 
      result.ex = ex
7073 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7074 
    result.write(oprot)
7075 
    oprot.writeMessageEnd()
7076 
    oprot.trans.flush()
1886 ankur.sing 7077 
 
4712 rajveer 7078 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7079 
    args = markOrderAsDelivered_args()
7080 
    args.read(iprot)
7081 
    iprot.readMessageEnd()
7082 
    result = markOrderAsDelivered_result()
7083 
    try:
7084 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7085 
    except TransactionServiceException, ex:
7086 
      result.ex = ex
7087 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7088 
    result.write(oprot)
7089 
    oprot.writeMessageEnd()
7090 
    oprot.trans.flush()
7091 
 
5553 rajveer 7092 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7093 
    args = markOrderAsReceivedAtStore_args()
7094 
    args.read(iprot)
7095 
    iprot.readMessageEnd()
7096 
    result = markOrderAsReceivedAtStore_result()
7097 
    try:
7098 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7099 
    except TransactionServiceException, ex:
7100 
      result.ex = ex
7101 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
7105 
 
4454 rajveer 7106 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7107 
    args = markOrderDoaRequestReceived_args()
7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
7110 
    result = markOrderDoaRequestReceived_result()
7111 
    try:
7112 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7113 
    except TransactionServiceException, ex:
7114 
      result.ex = ex
7115 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
7119 
 
7120 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7121 
    args = markOrderDoaRequestAuthorized_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = markOrderDoaRequestAuthorized_result()
7125 
    try:
7126 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7127 
    except TransactionServiceException, ex:
7128 
      result.ex = ex
7129 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7130 
    result.write(oprot)
7131 
    oprot.writeMessageEnd()
7132 
    oprot.trans.flush()
7133 
 
4488 rajveer 7134 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7135 
    args = markOrderReturnRequestReceived_args()
7136 
    args.read(iprot)
7137 
    iprot.readMessageEnd()
7138 
    result = markOrderReturnRequestReceived_result()
7139 
    try:
7140 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7141 
    except TransactionServiceException, ex:
7142 
      result.ex = ex
7143 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7144 
    result.write(oprot)
7145 
    oprot.writeMessageEnd()
7146 
    oprot.trans.flush()
7147 
 
7148 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7149 
    args = markOrderReturnRequestAuthorized_args()
7150 
    args.read(iprot)
7151 
    iprot.readMessageEnd()
7152 
    result = markOrderReturnRequestAuthorized_result()
7153 
    try:
7154 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7155 
    except TransactionServiceException, ex:
7156 
      result.ex = ex
7157 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7158 
    result.write(oprot)
7159 
    oprot.writeMessageEnd()
7160 
    oprot.trans.flush()
7161 
 
2536 chandransh 7162 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7163 
    args = requestPickupNumber_args()
7164 
    args.read(iprot)
7165 
    iprot.readMessageEnd()
7166 
    result = requestPickupNumber_result()
7167 
    try:
4579 rajveer 7168 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7169 
    except TransactionServiceException, ex:
7170 
      result.ex = ex
7171 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7172 
    result.write(oprot)
7173 
    oprot.writeMessageEnd()
7174 
    oprot.trans.flush()
7175 
 
7176 
  def process_authorizePickup(self, seqid, iprot, oprot):
7177 
    args = authorizePickup_args()
7178 
    args.read(iprot)
7179 
    iprot.readMessageEnd()
7180 
    result = authorizePickup_result()
7181 
    try:
4602 rajveer 7182 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7183 
    except TransactionServiceException, ex:
7184 
      result.ex = ex
7185 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7186 
    result.write(oprot)
7187 
    oprot.writeMessageEnd()
7188 
    oprot.trans.flush()
7189 
 
2764 chandransh 7190 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7191 
    args = markDoasAsPickedUp_args()
7192 
    args.read(iprot)
7193 
    iprot.readMessageEnd()
7194 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7195 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7196 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7197 
    result.write(oprot)
7198 
    oprot.writeMessageEnd()
7199 
    oprot.trans.flush()
7200 
 
4910 phani.kuma 7201 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7202 
    args = getDoasNotPickedUp_args()
7203 
    args.read(iprot)
7204 
    iprot.readMessageEnd()
7205 
    result = getDoasNotPickedUp_result()
7206 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7207 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7208 
    result.write(oprot)
7209 
    oprot.writeMessageEnd()
7210 
    oprot.trans.flush()
7211 
 
4741 phani.kuma 7212 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7213 
    args = markReturnOrdersAsPickedUp_args()
7214 
    args.read(iprot)
7215 
    iprot.readMessageEnd()
7216 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7217 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7218 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7219 
    result.write(oprot)
7220 
    oprot.writeMessageEnd()
7221 
    oprot.trans.flush()
7222 
 
4910 phani.kuma 7223 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7224 
    args = getReturnOrdersNotPickedUp_args()
7225 
    args.read(iprot)
7226 
    iprot.readMessageEnd()
7227 
    result = getReturnOrdersNotPickedUp_result()
7228 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7229 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
2616 chandransh 7234 
  def process_receiveReturn(self, seqid, iprot, oprot):
7235 
    args = receiveReturn_args()
2591 chandransh 7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
2616 chandransh 7238 
    result = receiveReturn_result()
2591 chandransh 7239 
    try:
4479 rajveer 7240 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7241 
    except TransactionServiceException, ex:
7242 
      result.ex = ex
2616 chandransh 7243 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7244 
    result.write(oprot)
7245 
    oprot.writeMessageEnd()
7246 
    oprot.trans.flush()
2536 chandransh 7247 
 
2591 chandransh 7248 
  def process_validateDoa(self, seqid, iprot, oprot):
7249 
    args = validateDoa_args()
7250 
    args.read(iprot)
7251 
    iprot.readMessageEnd()
7252 
    result = validateDoa_result()
7253 
    try:
7254 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7255 
    except TransactionServiceException, ex:
7256 
      result.ex = ex
7257 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
7261 
 
4495 rajveer 7262 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7263 
    args = validateReturnProduct_args()
7264 
    args.read(iprot)
7265 
    iprot.readMessageEnd()
7266 
    result = validateReturnProduct_result()
7267 
    try:
7268 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7269 
    except TransactionServiceException, ex:
7270 
      result.ex = ex
7271 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7272 
    result.write(oprot)
7273 
    oprot.writeMessageEnd()
7274 
    oprot.trans.flush()
7275 
 
2616 chandransh 7276 
  def process_reshipOrder(self, seqid, iprot, oprot):
7277 
    args = reshipOrder_args()
7278 
    args.read(iprot)
7279 
    iprot.readMessageEnd()
7280 
    result = reshipOrder_result()
7281 
    try:
7282 
      result.success = self._handler.reshipOrder(args.orderId)
7283 
    except TransactionServiceException, ex:
7284 
      result.ex = ex
7285 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7286 
    result.write(oprot)
7287 
    oprot.writeMessageEnd()
7288 
    oprot.trans.flush()
2591 chandransh 7289 
 
2616 chandransh 7290 
  def process_refundOrder(self, seqid, iprot, oprot):
7291 
    args = refundOrder_args()
7292 
    args.read(iprot)
7293 
    iprot.readMessageEnd()
7294 
    result = refundOrder_result()
7295 
    try:
3226 chandransh 7296 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7297 
    except TransactionServiceException, ex:
7298 
      result.ex = ex
7299 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7303 
 
2690 chandransh 7304 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7305 
    args = getReturnOrders_args()
7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
7308 
    result = getReturnOrders_result()
7309 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7310 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
2616 chandransh 7314 
 
5481 phani.kuma 7315 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7316 
    args = getAllReturnOrders_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = getAllReturnOrders_result()
7320 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7321 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7322 
    result.write(oprot)
7323 
    oprot.writeMessageEnd()
7324 
    oprot.trans.flush()
7325 
 
2700 chandransh 7326 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7327 
    args = getReturnOrder_args()
7328 
    args.read(iprot)
7329 
    iprot.readMessageEnd()
7330 
    result = getReturnOrder_result()
7331 
    try:
7332 
      result.success = self._handler.getReturnOrder(args.id)
7333 
    except TransactionServiceException, ex:
7334 
      result.ex = ex
7335 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7336 
    result.write(oprot)
7337 
    oprot.writeMessageEnd()
7338 
    oprot.trans.flush()
7339 
 
2690 chandransh 7340 
  def process_processReturn(self, seqid, iprot, oprot):
7341 
    args = processReturn_args()
7342 
    args.read(iprot)
7343 
    iprot.readMessageEnd()
7344 
    result = processReturn_result()
7345 
    try:
7346 
      self._handler.processReturn(args.returnOrderId)
7347 
    except TransactionServiceException, ex:
7348 
      result.ex = ex
7349 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7350 
    result.write(oprot)
7351 
    oprot.writeMessageEnd()
7352 
    oprot.trans.flush()
7353 
 
3451 chandransh 7354 
  def process_updateWeight(self, seqid, iprot, oprot):
7355 
    args = updateWeight_args()
7356 
    args.read(iprot)
7357 
    iprot.readMessageEnd()
7358 
    result = updateWeight_result()
7359 
    try:
7360 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7361 
    except TransactionServiceException, ex:
7362 
      result.ex = ex
7363 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7364 
    result.write(oprot)
7365 
    oprot.writeMessageEnd()
7366 
    oprot.trans.flush()
2819 chandransh 7367 
 
3469 chandransh 7368 
  def process_changeItem(self, seqid, iprot, oprot):
7369 
    args = changeItem_args()
7370 
    args.read(iprot)
7371 
    iprot.readMessageEnd()
7372 
    result = changeItem_result()
7373 
    try:
7374 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7375 
    except TransactionServiceException, ex:
7376 
      result.ex = ex
7377 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7378 
    result.write(oprot)
7379 
    oprot.writeMessageEnd()
7380 
    oprot.trans.flush()
3451 chandransh 7381 
 
3469 chandransh 7382 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7383 
    args = shiftToWarehouse_args()
7384 
    args.read(iprot)
7385 
    iprot.readMessageEnd()
7386 
    result = shiftToWarehouse_result()
7387 
    try:
7388 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7389 
    except TransactionServiceException, ex:
7390 
      result.ex = ex
7391 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7392 
    result.write(oprot)
7393 
    oprot.writeMessageEnd()
7394 
    oprot.trans.flush()
7395 
 
3553 chandransh 7396 
  def process_addDelayReason(self, seqid, iprot, oprot):
7397 
    args = addDelayReason_args()
7398 
    args.read(iprot)
7399 
    iprot.readMessageEnd()
7400 
    result = addDelayReason_result()
7401 
    try:
4647 rajveer 7402 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7403 
    except TransactionServiceException, ex:
7404 
      result.ex = ex
7405 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7406 
    result.write(oprot)
7407 
    oprot.writeMessageEnd()
7408 
    oprot.trans.flush()
3469 chandransh 7409 
 
3956 chandransh 7410 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7411 
    args = reconcileCodCollection_args()
7412 
    args.read(iprot)
7413 
    iprot.readMessageEnd()
7414 
    result = reconcileCodCollection_result()
7415 
    try:
7416 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7417 
    except TransactionServiceException, ex:
7418 
      result.ex = ex
7419 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7420 
    result.write(oprot)
7421 
    oprot.writeMessageEnd()
7422 
    oprot.trans.flush()
3553 chandransh 7423 
 
4008 mandeep.dh 7424 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7425 
    args = getTransactionsRequiringExtraProcessing_args()
7426 
    args.read(iprot)
7427 
    iprot.readMessageEnd()
7428 
    result = getTransactionsRequiringExtraProcessing_result()
7429 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7430 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
3956 chandransh 7434 
 
4008 mandeep.dh 7435 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7436 
    args = markTransactionAsProcessed_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = markTransactionAsProcessed_result()
7440 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7441 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
7445 
 
4018 chandransh 7446 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7447 
    args = getItemWiseRiskyOrdersCount_args()
7448 
    args.read(iprot)
7449 
    iprot.readMessageEnd()
7450 
    result = getItemWiseRiskyOrdersCount_result()
7451 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7452 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7453 
    result.write(oprot)
7454 
    oprot.writeMessageEnd()
7455 
    oprot.trans.flush()
4008 mandeep.dh 7456 
 
4295 varun.gupt 7457 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7458 
    args = getOrdersForItemIds_args()
7459 
    args.read(iprot)
7460 
    iprot.readMessageEnd()
7461 
    result = getOrdersForItemIds_result()
7462 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7463 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7464 
    result.write(oprot)
7465 
    oprot.writeMessageEnd()
7466 
    oprot.trans.flush()
7467 
 
4247 rajveer 7468 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7469 
    args = markOrderCancellationRequestReceived_args()
7470 
    args.read(iprot)
7471 
    iprot.readMessageEnd()
7472 
    result = markOrderCancellationRequestReceived_result()
7473 
    try:
7474 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7475 
    except TransactionServiceException, ex:
7476 
      result.ex = ex
7477 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7478 
    result.write(oprot)
7479 
    oprot.writeMessageEnd()
7480 
    oprot.trans.flush()
4018 chandransh 7481 
 
4247 rajveer 7482 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7483 
    args = markOrderCancellationRequestConfirmed_args()
7484 
    args.read(iprot)
7485 
    iprot.readMessageEnd()
7486 
    result = markOrderCancellationRequestConfirmed_result()
7487 
    try:
7488 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7489 
    except TransactionServiceException, ex:
7490 
      result.ex = ex
7491 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7492 
    result.write(oprot)
7493 
    oprot.writeMessageEnd()
7494 
    oprot.trans.flush()
7495 
 
7496 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7497 
    args = markOrderCancellationRequestDenied_args()
7498 
    args.read(iprot)
7499 
    iprot.readMessageEnd()
7500 
    result = markOrderCancellationRequestDenied_result()
7501 
    try:
7502 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7503 
    except TransactionServiceException, ex:
7504 
      result.ex = ex
7505 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7506 
    result.write(oprot)
7507 
    oprot.writeMessageEnd()
7508 
    oprot.trans.flush()
7509 
 
4258 rajveer 7510 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7511 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7512 
    args.read(iprot)
7513 
    iprot.readMessageEnd()
4258 rajveer 7514 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7515 
    try:
4258 rajveer 7516 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7517 
    except TransactionServiceException, ex:
7518 
      result.ex = ex
4258 rajveer 7519 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7520 
    result.write(oprot)
7521 
    oprot.writeMessageEnd()
7522 
    oprot.trans.flush()
7523 
 
4259 anupam.sin 7524 
  def process_refundTransaction(self, seqid, iprot, oprot):
7525 
    args = refundTransaction_args()
7526 
    args.read(iprot)
7527 
    iprot.readMessageEnd()
7528 
    result = refundTransaction_result()
7529 
    try:
7530 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7531 
    except TransactionServiceException, ex:
7532 
      result.ex = ex
7533 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7534 
    result.write(oprot)
7535 
    oprot.writeMessageEnd()
7536 
    oprot.trans.flush()
4247 rajveer 7537 
 
4324 mandeep.dh 7538 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7539 
    args = updateShipmentAddress_args()
7540 
    args.read(iprot)
7541 
    iprot.readMessageEnd()
7542 
    result = updateShipmentAddress_result()
7543 
    try:
7544 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7545 
    except TransactionServiceException, ex:
7546 
      result.ex = ex
7547 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7548 
    result.write(oprot)
7549 
    oprot.writeMessageEnd()
7550 
    oprot.trans.flush()
7551 
 
4285 rajveer 7552 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7553 
    args = acceptOrdersForItemId_args()
7554 
    args.read(iprot)
7555 
    iprot.readMessageEnd()
7556 
    result = acceptOrdersForItemId_result()
7557 
    try:
7558 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7559 
    except TransactionServiceException, ex:
7560 
      result.ex = ex
7561 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7562 
    result.write(oprot)
7563 
    oprot.writeMessageEnd()
7564 
    oprot.trans.flush()
4259 anupam.sin 7565 
 
4303 rajveer 7566 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7567 
    args = markOrdersAsPORaised_args()
7568 
    args.read(iprot)
7569 
    iprot.readMessageEnd()
7570 
    result = markOrdersAsPORaised_result()
7571 
    try:
4369 rajveer 7572 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7573 
    except TransactionServiceException, ex:
7574 
      result.ex = ex
7575 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
4285 rajveer 7579 
 
4303 rajveer 7580 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7581 
    args = markOrdersAsReversalInitiated_args()
7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
7584 
    result = markOrdersAsReversalInitiated_result()
7585 
    try:
4369 rajveer 7586 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7587 
    except TransactionServiceException, ex:
7588 
      result.ex = ex
7589 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7590 
    result.write(oprot)
7591 
    oprot.writeMessageEnd()
7592 
    oprot.trans.flush()
7593 
 
7594 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7595 
    args = markOrdersAsNotAvailabke_args()
7596 
    args.read(iprot)
7597 
    iprot.readMessageEnd()
7598 
    result = markOrdersAsNotAvailabke_result()
7599 
    try:
4369 rajveer 7600 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7601 
    except TransactionServiceException, ex:
7602 
      result.ex = ex
7603 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7604 
    result.write(oprot)
7605 
    oprot.writeMessageEnd()
7606 
    oprot.trans.flush()
7607 
 
4369 rajveer 7608 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7609 
    args = markOrdersAsTimeout_args()
7610 
    args.read(iprot)
7611 
    iprot.readMessageEnd()
7612 
    result = markOrdersAsTimeout_result()
7613 
    try:
7614 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7615 
    except TransactionServiceException, ex:
7616 
      result.ex = ex
7617 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7618 
    result.write(oprot)
7619 
    oprot.writeMessageEnd()
7620 
    oprot.trans.flush()
4303 rajveer 7621 
 
4662 rajveer 7622 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7623 
    args = markOrderAsLostInTransit_args()
7624 
    args.read(iprot)
7625 
    iprot.readMessageEnd()
7626 
    result = markOrderAsLostInTransit_result()
7627 
    try:
7628 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7629 
    except TransactionServiceException, ex:
7630 
      result.ex = ex
7631 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7632 
    result.write(oprot)
7633 
    oprot.writeMessageEnd()
7634 
    oprot.trans.flush()
7635 
 
4386 anupam.sin 7636 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7637 
    args = getOrderForAwb_args()
7638 
    args.read(iprot)
7639 
    iprot.readMessageEnd()
7640 
    result = getOrderForAwb_result()
7641 
    try:
7642 
      result.success = self._handler.getOrderForAwb(args.awb)
7643 
    except TransactionServiceException, ex:
7644 
      result.ex = ex
7645 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7646 
    result.write(oprot)
7647 
    oprot.writeMessageEnd()
7648 
    oprot.trans.flush()
4369 rajveer 7649 
 
4506 phani.kuma 7650 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7651 
    args = getOrdersForProviderForStatus_args()
7652 
    args.read(iprot)
7653 
    iprot.readMessageEnd()
7654 
    result = getOrdersForProviderForStatus_result()
7655 
    try:
4910 phani.kuma 7656 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7657 
    except TransactionServiceException, ex:
7658 
      result.ex = ex
7659 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7660 
    result.write(oprot)
7661 
    oprot.writeMessageEnd()
7662 
    oprot.trans.flush()
4386 anupam.sin 7663 
 
4600 varun.gupt 7664 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7665 
    args = getBilledOrdersForVendor_args()
7666 
    args.read(iprot)
7667 
    iprot.readMessageEnd()
7668 
    result = getBilledOrdersForVendor_result()
7669 
    try:
7670 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7671 
    except TransactionServiceException, ex:
7672 
      result.ex = ex
7673 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7674 
    result.write(oprot)
7675 
    oprot.writeMessageEnd()
7676 
    oprot.trans.flush()
4506 phani.kuma 7677 
 
4607 rajveer 7678 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7679 
    args = getSlippedSippingDateOrders_args()
7680 
    args.read(iprot)
7681 
    iprot.readMessageEnd()
7682 
    result = getSlippedSippingDateOrders_result()
7683 
    try:
7684 
      result.success = self._handler.getSlippedSippingDateOrders()
7685 
    except TransactionServiceException, ex:
7686 
      result.ex = ex
7687 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7688 
    result.write(oprot)
7689 
    oprot.writeMessageEnd()
7690 
    oprot.trans.flush()
7691 
 
4709 rajveer 7692 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7693 
    args = getCancelledOrders_args()
7694 
    args.read(iprot)
7695 
    iprot.readMessageEnd()
7696 
    result = getCancelledOrders_result()
7697 
    try:
7698 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7699 
    except TransactionServiceException, ex:
7700 
      result.ex = ex
7701 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7702 
    result.write(oprot)
7703 
    oprot.writeMessageEnd()
7704 
    oprot.trans.flush()
7705 
 
4600 varun.gupt 7706 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7707 
    args = saveBluedartSettlements_args()
7708 
    args.read(iprot)
7709 
    iprot.readMessageEnd()
7710 
    result = saveBluedartSettlements_result()
7711 
    try:
7712 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7713 
    except TransactionServiceException, ex:
7714 
      result.ex = ex
7715 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7716 
    result.write(oprot)
7717 
    oprot.writeMessageEnd()
7718 
    oprot.trans.flush()
7719 
 
7720 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7721 
    args = savePaymentSettlements_args()
7722 
    args.read(iprot)
7723 
    iprot.readMessageEnd()
7724 
    result = savePaymentSettlements_result()
7725 
    try:
4905 varun.gupt 7726 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7727 
    except TransactionServiceException, ex:
7728 
      result.ex = ex
7729 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7730 
    result.write(oprot)
7731 
    oprot.writeMessageEnd()
7732 
    oprot.trans.flush()
7733 
 
7734 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7735 
    args = saveEBSSettlementSummary_args()
7736 
    args.read(iprot)
7737 
    iprot.readMessageEnd()
7738 
    result = saveEBSSettlementSummary_result()
7739 
    try:
7740 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7741 
    except TransactionServiceException, ex:
7742 
      result.ex = ex
7743 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7744 
    result.write(oprot)
7745 
    oprot.writeMessageEnd()
7746 
    oprot.trans.flush()
7747 
 
5386 phani.kuma 7748 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7749 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7750 
    args.read(iprot)
7751 
    iprot.readMessageEnd()
5386 phani.kuma 7752 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7753 
    try:
5386 phani.kuma 7754 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7755 
    except TransactionServiceException, ex:
7756 
      result.ex = ex
5386 phani.kuma 7757 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7758 
    result.write(oprot)
7759 
    oprot.writeMessageEnd()
7760 
    oprot.trans.flush()
7761 
 
5386 phani.kuma 7762 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7763 
    args = getSettlementForCod_args()
7764 
    args.read(iprot)
7765 
    iprot.readMessageEnd()
7766 
    result = getSettlementForCod_result()
7767 
    try:
7768 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7769 
    except TransactionServiceException, ex:
7770 
      result.ex = ex
7771 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7772 
    result.write(oprot)
7773 
    oprot.writeMessageEnd()
7774 
    oprot.trans.flush()
7775 
 
4600 varun.gupt 7776 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7777 
    args = getEBSSettlementSummaries_args()
7778 
    args.read(iprot)
7779 
    iprot.readMessageEnd()
7780 
    result = getEBSSettlementSummaries_result()
7781 
    try:
7782 
      result.success = self._handler.getEBSSettlementSummaries()
7783 
    except TransactionServiceException, ex:
7784 
      result.ex = ex
7785 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7786 
    result.write(oprot)
7787 
    oprot.writeMessageEnd()
7788 
    oprot.trans.flush()
7789 
 
7790 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7791 
    args = markEBSSettlementUploaded_args()
7792 
    args.read(iprot)
7793 
    iprot.readMessageEnd()
7794 
    result = markEBSSettlementUploaded_result()
7795 
    try:
7796 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7797 
    except TransactionServiceException, ex:
7798 
      result.ex = ex
7799 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7800 
    result.write(oprot)
7801 
    oprot.writeMessageEnd()
7802 
    oprot.trans.flush()
7803 
 
7804 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7805 
    args = getEBSSettlementDate_args()
7806 
    args.read(iprot)
7807 
    iprot.readMessageEnd()
7808 
    result = getEBSSettlementDate_result()
7809 
    try:
7810 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7811 
    except TransactionServiceException, ex:
7812 
      result.ex = ex
7813 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7814 
    result.write(oprot)
7815 
    oprot.writeMessageEnd()
7816 
    oprot.trans.flush()
7817 
 
4715 varun.gupt 7818 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7819 
    args = getSettlementsByDate_args()
7820 
    args.read(iprot)
7821 
    iprot.readMessageEnd()
7822 
    result = getSettlementsByDate_result()
7823 
    try:
7824 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7825 
    except TransactionServiceException, ex:
7826 
      result.ex = ex
7827 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7828 
    result.write(oprot)
7829 
    oprot.writeMessageEnd()
7830 
    oprot.trans.flush()
4600 varun.gupt 7831 
 
4715 varun.gupt 7832 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7833 
    args = getReshippedOrderIds_args()
7834 
    args.read(iprot)
7835 
    iprot.readMessageEnd()
7836 
    result = getReshippedOrderIds_result()
7837 
    try:
7838 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7839 
    except TransactionServiceException, ex:
7840 
      result.ex = ex
7841 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7842 
    result.write(oprot)
7843 
    oprot.writeMessageEnd()
7844 
    oprot.trans.flush()
7845 
 
5481 phani.kuma 7846 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7847 
    args = getBilledOrders_args()
4875 varun.gupt 7848 
    args.read(iprot)
7849 
    iprot.readMessageEnd()
5481 phani.kuma 7850 
    result = getBilledOrders_result()
4875 varun.gupt 7851 
    try:
5481 phani.kuma 7852 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7853 
    except TransactionServiceException, ex:
7854 
      result.ex = ex
5481 phani.kuma 7855 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7856 
    result.write(oprot)
7857 
    oprot.writeMessageEnd()
7858 
    oprot.trans.flush()
4757 mandeep.dh 7859 
 
5031 varun.gupt 7860 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7861 
    args = getStatusDistributionOfOrders_args()
7862 
    args.read(iprot)
7863 
    iprot.readMessageEnd()
7864 
    result = getStatusDistributionOfOrders_result()
7865 
    try:
7866 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7867 
    except TransactionServiceException, ex:
7868 
      result.ex = ex
7869 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7870 
    result.write(oprot)
7871 
    oprot.writeMessageEnd()
7872 
    oprot.trans.flush()
4875 varun.gupt 7873 
 
5067 varun.gupt 7874 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7875 
    args = getOrderIdsForStatus_args()
7876 
    args.read(iprot)
7877 
    iprot.readMessageEnd()
7878 
    result = getOrderIdsForStatus_result()
7879 
    try:
7880 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7881 
    except TransactionServiceException, ex:
7882 
      result.ex = ex
7883 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7884 
    result.write(oprot)
7885 
    oprot.writeMessageEnd()
7886 
    oprot.trans.flush()
5031 varun.gupt 7887 
 
5348 anupam.sin 7888 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7889 
    args = updateCODAgent_args()
7890 
    args.read(iprot)
7891 
    iprot.readMessageEnd()
7892 
    result = updateCODAgent_result()
7893 
    try:
7894 
      self._handler.updateCODAgent(args.agent, args.orderId)
7895 
    except TransactionServiceException, ex:
7896 
      result.ex = ex
7897 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7898 
    result.write(oprot)
7899 
    oprot.writeMessageEnd()
7900 
    oprot.trans.flush()
7901 
 
5099 varun.gupt 7902 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7903 
    args = updateOrderAsPaidToVendor_args()
7904 
    args.read(iprot)
7905 
    iprot.readMessageEnd()
7906 
    result = updateOrderAsPaidToVendor_result()
7907 
    try:
7908 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7909 
    except TransactionServiceException, ex:
7910 
      result.ex = ex
7911 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7912 
    result.write(oprot)
7913 
    oprot.writeMessageEnd()
7914 
    oprot.trans.flush()
5067 varun.gupt 7915 
 
5386 phani.kuma 7916 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7917 
    args = updateOrderOnlyAsPaidToVendor_args()
7918 
    args.read(iprot)
7919 
    iprot.readMessageEnd()
7920 
    result = updateOrderOnlyAsPaidToVendor_result()
7921 
    try:
7922 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7923 
    except TransactionServiceException, ex:
7924 
      result.ex = ex
7925 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7926 
    result.write(oprot)
7927 
    oprot.writeMessageEnd()
7928 
    oprot.trans.flush()
7929 
 
5208 varun.gupt 7930 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7931 
    args = getRefundedOrdersMarkedPaid_args()
7932 
    args.read(iprot)
7933 
    iprot.readMessageEnd()
7934 
    result = getRefundedOrdersMarkedPaid_result()
7935 
    try:
7936 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7937 
    except TransactionServiceException, ex:
7938 
      result.ex = ex
7939 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7940 
    result.write(oprot)
7941 
    oprot.writeMessageEnd()
7942 
    oprot.trans.flush()
5099 varun.gupt 7943 
 
5447 anupam.sin 7944 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7945 
    args = getAllVerificationAgents_args()
7946 
    args.read(iprot)
7947 
    iprot.readMessageEnd()
7948 
    result = getAllVerificationAgents_result()
7949 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7950 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7951 
    result.write(oprot)
7952 
    oprot.writeMessageEnd()
7953 
    oprot.trans.flush()
5208 varun.gupt 7954 
 
5527 anupam.sin 7955 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7956 
    args = getAllAttributesForOrderId_args()
7957 
    args.read(iprot)
7958 
    iprot.readMessageEnd()
7959 
    result = getAllAttributesForOrderId_result()
7960 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7961 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7962 
    result.write(oprot)
7963 
    oprot.writeMessageEnd()
7964 
    oprot.trans.flush()
5447 anupam.sin 7965 
 
5676 rajveer 7966 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7967 
    args = setOrderAttributes_args()
7968 
    args.read(iprot)
7969 
    iprot.readMessageEnd()
7970 
    result = setOrderAttributes_result()
7971 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7972 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
7976 
 
5527 anupam.sin 7977 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7978 
    args = setOrderAttributeForTransaction_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = setOrderAttributeForTransaction_result()
7982 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7983 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7984 
    result.write(oprot)
7985 
    oprot.writeMessageEnd()
7986 
    oprot.trans.flush()
7987 
 
5553 rajveer 7988 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7989 
    args = getReceivePendingOrders_args()
7990 
    args.read(iprot)
7991 
    iprot.readMessageEnd()
7992 
    result = getReceivePendingOrders_result()
7993 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7994 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7995 
    result.write(oprot)
7996 
    oprot.writeMessageEnd()
7997 
    oprot.trans.flush()
5527 anupam.sin 7998 
 
5553 rajveer 7999 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8000 
    args = getReceivedAtStoreOrders_args()
8001 
    args.read(iprot)
8002 
    iprot.readMessageEnd()
8003 
    result = getReceivedAtStoreOrders_result()
8004 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8005 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8006 
    result.write(oprot)
8007 
    oprot.writeMessageEnd()
8008 
    oprot.trans.flush()
8009 
 
5713 rajveer 8010 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8011 
    args = getOrdersCollectionAtStore_args()
8012 
    args.read(iprot)
8013 
    iprot.readMessageEnd()
8014 
    result = getOrdersCollectionAtStore_result()
8015 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8016 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8017 
    result.write(oprot)
8018 
    oprot.writeMessageEnd()
8019 
    oprot.trans.flush()
8020 
 
5833 rajveer 8021 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8022 
    args = getOrderAttributeValue_args()
8023 
    args.read(iprot)
8024 
    iprot.readMessageEnd()
8025 
    result = getOrderAttributeValue_result()
8026 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8027 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8028 
    result.write(oprot)
8029 
    oprot.writeMessageEnd()
8030 
    oprot.trans.flush()
8031 
 
6019 rajveer 8032 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8033 
    args = changeJacketNumber_args()
8034 
    args.read(iprot)
8035 
    iprot.readMessageEnd()
8036 
    result = changeJacketNumber_result()
8037 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8038 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8039 
    result.write(oprot)
8040 
    oprot.writeMessageEnd()
8041 
    oprot.trans.flush()
8042 
 
8043 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8044 
    args = markOrderAsRtoInTransit_args()
8045 
    args.read(iprot)
8046 
    iprot.readMessageEnd()
8047 
    result = markOrderAsRtoInTransit_result()
8048 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8049 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8050 
    result.write(oprot)
8051 
    oprot.writeMessageEnd()
8052 
    oprot.trans.flush()
8053 
 
5593 mandeep.dh 8054 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8055 
    args = acceptOrderForItem_args()
8056 
    args.read(iprot)
8057 
    iprot.readMessageEnd()
8058 
    result = acceptOrderForItem_result()
8059 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8060 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8061 
    result.write(oprot)
8062 
    oprot.writeMessageEnd()
8063 
    oprot.trans.flush()
5553 rajveer 8064 
 
6000 mandeep.dh 8065 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8066 
    args = createRechargeOrder_args()
8067 
    args.read(iprot)
8068 
    iprot.readMessageEnd()
8069 
    result = createRechargeOrder_result()
8070 
    try:
8071 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8072 
    except TransactionServiceException, ex:
8073 
      result.ex = ex
8074 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8075 
    result.write(oprot)
8076 
    oprot.writeMessageEnd()
8077 
    oprot.trans.flush()
5593 mandeep.dh 8078 
 
6031 rajveer 8079 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8080 
    args = getRechargeOrder_args()
8081 
    args.read(iprot)
8082 
    iprot.readMessageEnd()
8083 
    result = getRechargeOrder_result()
8084 
    try:
8085 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8086 
    except TransactionServiceException, ex:
8087 
      result.ex = ex
8088 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8089 
    result.write(oprot)
8090 
    oprot.writeMessageEnd()
8091 
    oprot.trans.flush()
8092 
 
8093 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8094 
    args = getRechargeOrders_args()
8095 
    args.read(iprot)
8096 
    iprot.readMessageEnd()
8097 
    result = getRechargeOrders_result()
8098 
    result.success = self._handler.getRechargeOrders(args.userId)
8099 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8100 
    result.write(oprot)
8101 
    oprot.writeMessageEnd()
8102 
    oprot.trans.flush()
8103 
 
6000 mandeep.dh 8104 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8105 
    args = updateRechargeOrderStatus_args()
8106 
    args.read(iprot)
8107 
    iprot.readMessageEnd()
8108 
    result = updateRechargeOrderStatus_result()
8109 
    try:
6031 rajveer 8110 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8111 
    except TransactionServiceException, ex:
8112 
      result.ex = ex
8113 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8114 
    result.write(oprot)
8115 
    oprot.writeMessageEnd()
8116 
    oprot.trans.flush()
8117 
 
8118 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8119 
    args = activateRechargeTxn_args()
8120 
    args.read(iprot)
8121 
    iprot.readMessageEnd()
8122 
    result = activateRechargeTxn_result()
8123 
    try:
6031 rajveer 8124 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8125 
    except TransactionServiceException, ex:
8126 
      result.ex = ex
8127 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8128 
    result.write(oprot)
8129 
    oprot.writeMessageEnd()
8130 
    oprot.trans.flush()
8131 
 
6031 rajveer 8132 
  def process_getUserWallet(self, seqid, iprot, oprot):
8133 
    args = getUserWallet_args()
6000 mandeep.dh 8134 
    args.read(iprot)
8135 
    iprot.readMessageEnd()
6031 rajveer 8136 
    result = getUserWallet_result()
8137 
    result.success = self._handler.getUserWallet(args.userId)
8138 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8139 
    result.write(oprot)
8140 
    oprot.writeMessageEnd()
8141 
    oprot.trans.flush()
8142 
 
6031 rajveer 8143 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8144 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8145 
    args.read(iprot)
8146 
    iprot.readMessageEnd()
6031 rajveer 8147 
    result = getUserWalletHistory_result()
8148 
    result.success = self._handler.getUserWalletHistory(args.userId)
8149 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8150 
    result.write(oprot)
8151 
    oprot.writeMessageEnd()
8152 
    oprot.trans.flush()
8153 
 
6050 anupam.sin 8154 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8155 
    args = getRechargeOrdersForTransaction_args()
8156 
    args.read(iprot)
8157 
    iprot.readMessageEnd()
8158 
    result = getRechargeOrdersForTransaction_result()
8159 
    try:
8160 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8161 
    except TransactionServiceException, ex:
8162 
      result.ex = ex
8163 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8164 
    result.write(oprot)
8165 
    oprot.writeMessageEnd()
8166 
    oprot.trans.flush()
8167 
 
6048 rajveer 8168 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8169 
    args = getServiceProviders_args()
8170 
    args.read(iprot)
8171 
    iprot.readMessageEnd()
8172 
    result = getServiceProviders_result()
8173 
    result.success = self._handler.getServiceProviders(args.rechargeType)
8174 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8175 
    result.write(oprot)
8176 
    oprot.writeMessageEnd()
8177 
    oprot.trans.flush()
6000 mandeep.dh 8178 
 
6048 rajveer 8179 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8180 
    args = getServiceProviderForDevice_args()
8181 
    args.read(iprot)
8182 
    iprot.readMessageEnd()
8183 
    result = getServiceProviderForDevice_result()
6049 rajveer 8184 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8185 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8186 
    result.write(oprot)
8187 
    oprot.writeMessageEnd()
8188 
    oprot.trans.flush()
8189 
 
6094 rajveer 8190 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8191 
    args = getRechargeOrdersForDevice_args()
8192 
    args.read(iprot)
8193 
    iprot.readMessageEnd()
8194 
    result = getRechargeOrdersForDevice_result()
8195 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8196 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8197 
    result.write(oprot)
8198 
    oprot.writeMessageEnd()
8199 
    oprot.trans.flush()
6048 rajveer 8200 
 
6094 rajveer 8201 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8202 
    args = addAmountToWallet_args()
8203 
    args.read(iprot)
8204 
    iprot.readMessageEnd()
8205 
    result = addAmountToWallet_result()
8206 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8207 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8208 
    result.write(oprot)
8209 
    oprot.writeMessageEnd()
8210 
    oprot.trans.flush()
8211 
 
6154 rajveer 8212 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8213 
    args = getRechargeOrdersForStatus_args()
8214 
    args.read(iprot)
8215 
    iprot.readMessageEnd()
8216 
    result = getRechargeOrdersForStatus_result()
8217 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8218 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8219 
    result.write(oprot)
8220 
    oprot.writeMessageEnd()
8221 
    oprot.trans.flush()
6094 rajveer 8222 
 
6154 rajveer 8223 
 
94 ashish 8224 
# HELPER FUNCTIONS AND STRUCTURES
8225 
 
8226 
class createTransaction_args:
8227 
  """
8228 
  Attributes:
8229 
   - transaction
8230 
  """
8231 
 
8232 
  thrift_spec = (
8233 
    None, # 0
8234 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8235 
  )
8236 
 
8237 
  def __init__(self, transaction=None,):
8238 
    self.transaction = transaction
8239 
 
8240 
  def read(self, iprot):
8241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8243 
      return
8244 
    iprot.readStructBegin()
8245 
    while True:
8246 
      (fname, ftype, fid) = iprot.readFieldBegin()
8247 
      if ftype == TType.STOP:
8248 
        break
8249 
      if fid == 1:
8250 
        if ftype == TType.STRUCT:
8251 
          self.transaction = Transaction()
8252 
          self.transaction.read(iprot)
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
8264 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8265 
    if self.transaction is not None:
94 ashish 8266 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8267 
      self.transaction.write(oprot)
8268 
      oprot.writeFieldEnd()
8269 
    oprot.writeFieldStop()
8270 
    oprot.writeStructEnd()
8271 
 
3431 rajveer 8272 
  def validate(self):
8273 
    return
8274 
 
8275 
 
94 ashish 8276 
  def __repr__(self):
8277 
    L = ['%s=%r' % (key, value)
8278 
      for key, value in self.__dict__.iteritems()]
8279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8280 
 
8281 
  def __eq__(self, other):
8282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8283 
 
8284 
  def __ne__(self, other):
8285 
    return not (self == other)
8286 
 
8287 
class createTransaction_result:
8288 
  """
8289 
  Attributes:
132 ashish 8290 
   - success
94 ashish 8291 
   - ex
8292 
  """
8293 
 
8294 
  thrift_spec = (
132 ashish 8295 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8297 
  )
8298 
 
132 ashish 8299 
  def __init__(self, success=None, ex=None,):
8300 
    self.success = success
94 ashish 8301 
    self.ex = ex
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
132 ashish 8312 
      if fid == 0:
8313 
        if ftype == TType.I64:
8314 
          self.success = iprot.readI64();
8315 
        else:
8316 
          iprot.skip(ftype)
8317 
      elif fid == 1:
94 ashish 8318 
        if ftype == TType.STRUCT:
8319 
          self.ex = TransactionServiceException()
8320 
          self.ex.read(iprot)
8321 
        else:
8322 
          iprot.skip(ftype)
8323 
      else:
8324 
        iprot.skip(ftype)
8325 
      iprot.readFieldEnd()
8326 
    iprot.readStructEnd()
8327 
 
8328 
  def write(self, oprot):
8329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8331 
      return
8332 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8333 
    if self.success is not None:
132 ashish 8334 
      oprot.writeFieldBegin('success', TType.I64, 0)
8335 
      oprot.writeI64(self.success)
8336 
      oprot.writeFieldEnd()
3431 rajveer 8337 
    if self.ex is not None:
94 ashish 8338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8339 
      self.ex.write(oprot)
8340 
      oprot.writeFieldEnd()
8341 
    oprot.writeFieldStop()
8342 
    oprot.writeStructEnd()
8343 
 
3431 rajveer 8344 
  def validate(self):
8345 
    return
8346 
 
8347 
 
94 ashish 8348 
  def __repr__(self):
8349 
    L = ['%s=%r' % (key, value)
8350 
      for key, value in self.__dict__.iteritems()]
8351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8352 
 
8353 
  def __eq__(self, other):
8354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8355 
 
8356 
  def __ne__(self, other):
8357 
    return not (self == other)
8358 
 
8359 
class getTransaction_args:
8360 
  """
8361 
  Attributes:
8362 
   - id
8363 
  """
8364 
 
8365 
  thrift_spec = (
8366 
    None, # 0
8367 
    (1, TType.I64, 'id', None, None, ), # 1
8368 
  )
8369 
 
8370 
  def __init__(self, id=None,):
8371 
    self.id = id
8372 
 
8373 
  def read(self, iprot):
8374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8376 
      return
8377 
    iprot.readStructBegin()
8378 
    while True:
8379 
      (fname, ftype, fid) = iprot.readFieldBegin()
8380 
      if ftype == TType.STOP:
8381 
        break
8382 
      if fid == 1:
8383 
        if ftype == TType.I64:
8384 
          self.id = iprot.readI64();
8385 
        else:
8386 
          iprot.skip(ftype)
8387 
      else:
8388 
        iprot.skip(ftype)
8389 
      iprot.readFieldEnd()
8390 
    iprot.readStructEnd()
8391 
 
8392 
  def write(self, oprot):
8393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8395 
      return
8396 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8397 
    if self.id is not None:
94 ashish 8398 
      oprot.writeFieldBegin('id', TType.I64, 1)
8399 
      oprot.writeI64(self.id)
8400 
      oprot.writeFieldEnd()
8401 
    oprot.writeFieldStop()
8402 
    oprot.writeStructEnd()
8403 
 
3431 rajveer 8404 
  def validate(self):
8405 
    return
8406 
 
8407 
 
94 ashish 8408 
  def __repr__(self):
8409 
    L = ['%s=%r' % (key, value)
8410 
      for key, value in self.__dict__.iteritems()]
8411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8412 
 
8413 
  def __eq__(self, other):
8414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8415 
 
8416 
  def __ne__(self, other):
8417 
    return not (self == other)
8418 
 
8419 
class getTransaction_result:
8420 
  """
8421 
  Attributes:
8422 
   - success
8423 
   - ex
8424 
  """
8425 
 
8426 
  thrift_spec = (
8427 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8429 
  )
8430 
 
8431 
  def __init__(self, success=None, ex=None,):
8432 
    self.success = success
8433 
    self.ex = ex
8434 
 
8435 
  def read(self, iprot):
8436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8438 
      return
8439 
    iprot.readStructBegin()
8440 
    while True:
8441 
      (fname, ftype, fid) = iprot.readFieldBegin()
8442 
      if ftype == TType.STOP:
8443 
        break
8444 
      if fid == 0:
8445 
        if ftype == TType.STRUCT:
8446 
          self.success = Transaction()
8447 
          self.success.read(iprot)
8448 
        else:
8449 
          iprot.skip(ftype)
8450 
      elif fid == 1:
8451 
        if ftype == TType.STRUCT:
8452 
          self.ex = TransactionServiceException()
8453 
          self.ex.read(iprot)
8454 
        else:
8455 
          iprot.skip(ftype)
8456 
      else:
8457 
        iprot.skip(ftype)
8458 
      iprot.readFieldEnd()
8459 
    iprot.readStructEnd()
8460 
 
8461 
  def write(self, oprot):
8462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8464 
      return
8465 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8466 
    if self.success is not None:
94 ashish 8467 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8468 
      self.success.write(oprot)
8469 
      oprot.writeFieldEnd()
3431 rajveer 8470 
    if self.ex is not None:
94 ashish 8471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8472 
      self.ex.write(oprot)
8473 
      oprot.writeFieldEnd()
8474 
    oprot.writeFieldStop()
8475 
    oprot.writeStructEnd()
8476 
 
3431 rajveer 8477 
  def validate(self):
8478 
    return
8479 
 
8480 
 
94 ashish 8481 
  def __repr__(self):
8482 
    L = ['%s=%r' % (key, value)
8483 
      for key, value in self.__dict__.iteritems()]
8484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8485 
 
8486 
  def __eq__(self, other):
8487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8488 
 
8489 
  def __ne__(self, other):
8490 
    return not (self == other)
8491 
 
8492 
class getTransactionsForCustomer_args:
8493 
  """
8494 
  Attributes:
8495 
   - customerId
8496 
   - from_date
8497 
   - to_date
8498 
   - status
8499 
  """
8500 
 
8501 
  thrift_spec = (
8502 
    None, # 0
8503 
    (1, TType.I64, 'customerId', None, None, ), # 1
8504 
    (2, TType.I64, 'from_date', None, None, ), # 2
8505 
    (3, TType.I64, 'to_date', None, None, ), # 3
8506 
    (4, TType.I32, 'status', None, None, ), # 4
8507 
  )
8508 
 
8509 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8510 
    self.customerId = customerId
8511 
    self.from_date = from_date
8512 
    self.to_date = to_date
8513 
    self.status = status
8514 
 
8515 
  def read(self, iprot):
8516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8518 
      return
8519 
    iprot.readStructBegin()
8520 
    while True:
8521 
      (fname, ftype, fid) = iprot.readFieldBegin()
8522 
      if ftype == TType.STOP:
8523 
        break
8524 
      if fid == 1:
8525 
        if ftype == TType.I64:
8526 
          self.customerId = iprot.readI64();
8527 
        else:
8528 
          iprot.skip(ftype)
8529 
      elif fid == 2:
8530 
        if ftype == TType.I64:
8531 
          self.from_date = iprot.readI64();
8532 
        else:
8533 
          iprot.skip(ftype)
8534 
      elif fid == 3:
8535 
        if ftype == TType.I64:
8536 
          self.to_date = iprot.readI64();
8537 
        else:
8538 
          iprot.skip(ftype)
8539 
      elif fid == 4:
8540 
        if ftype == TType.I32:
8541 
          self.status = iprot.readI32();
8542 
        else:
8543 
          iprot.skip(ftype)
8544 
      else:
8545 
        iprot.skip(ftype)
8546 
      iprot.readFieldEnd()
8547 
    iprot.readStructEnd()
8548 
 
8549 
  def write(self, oprot):
8550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8552 
      return
8553 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8554 
    if self.customerId is not None:
94 ashish 8555 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8556 
      oprot.writeI64(self.customerId)
8557 
      oprot.writeFieldEnd()
3431 rajveer 8558 
    if self.from_date is not None:
94 ashish 8559 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8560 
      oprot.writeI64(self.from_date)
8561 
      oprot.writeFieldEnd()
3431 rajveer 8562 
    if self.to_date is not None:
94 ashish 8563 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8564 
      oprot.writeI64(self.to_date)
8565 
      oprot.writeFieldEnd()
3431 rajveer 8566 
    if self.status is not None:
94 ashish 8567 
      oprot.writeFieldBegin('status', TType.I32, 4)
8568 
      oprot.writeI32(self.status)
8569 
      oprot.writeFieldEnd()
8570 
    oprot.writeFieldStop()
8571 
    oprot.writeStructEnd()
8572 
 
3431 rajveer 8573 
  def validate(self):
8574 
    return
8575 
 
8576 
 
94 ashish 8577 
  def __repr__(self):
8578 
    L = ['%s=%r' % (key, value)
8579 
      for key, value in self.__dict__.iteritems()]
8580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8581 
 
8582 
  def __eq__(self, other):
8583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8584 
 
8585 
  def __ne__(self, other):
8586 
    return not (self == other)
8587 
 
8588 
class getTransactionsForCustomer_result:
8589 
  """
8590 
  Attributes:
8591 
   - success
8592 
   - ex
8593 
  """
8594 
 
8595 
  thrift_spec = (
8596 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8598 
  )
8599 
 
8600 
  def __init__(self, success=None, ex=None,):
8601 
    self.success = success
8602 
    self.ex = ex
8603 
 
8604 
  def read(self, iprot):
8605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8607 
      return
8608 
    iprot.readStructBegin()
8609 
    while True:
8610 
      (fname, ftype, fid) = iprot.readFieldBegin()
8611 
      if ftype == TType.STOP:
8612 
        break
8613 
      if fid == 0:
8614 
        if ftype == TType.LIST:
8615 
          self.success = []
6031 rajveer 8616 
          (_etype66, _size63) = iprot.readListBegin()
8617 
          for _i67 in xrange(_size63):
8618 
            _elem68 = Transaction()
8619 
            _elem68.read(iprot)
8620 
            self.success.append(_elem68)
94 ashish 8621 
          iprot.readListEnd()
8622 
        else:
8623 
          iprot.skip(ftype)
8624 
      elif fid == 1:
8625 
        if ftype == TType.STRUCT:
8626 
          self.ex = TransactionServiceException()
8627 
          self.ex.read(iprot)
8628 
        else:
8629 
          iprot.skip(ftype)
8630 
      else:
8631 
        iprot.skip(ftype)
8632 
      iprot.readFieldEnd()
8633 
    iprot.readStructEnd()
8634 
 
8635 
  def write(self, oprot):
8636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8638 
      return
8639 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8640 
    if self.success is not None:
94 ashish 8641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8643 
      for iter69 in self.success:
8644 
        iter69.write(oprot)
94 ashish 8645 
      oprot.writeListEnd()
8646 
      oprot.writeFieldEnd()
3431 rajveer 8647 
    if self.ex is not None:
94 ashish 8648 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8649 
      self.ex.write(oprot)
8650 
      oprot.writeFieldEnd()
8651 
    oprot.writeFieldStop()
8652 
    oprot.writeStructEnd()
8653 
 
3431 rajveer 8654 
  def validate(self):
8655 
    return
8656 
 
8657 
 
94 ashish 8658 
  def __repr__(self):
8659 
    L = ['%s=%r' % (key, value)
8660 
      for key, value in self.__dict__.iteritems()]
8661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8662 
 
8663 
  def __eq__(self, other):
8664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8665 
 
8666 
  def __ne__(self, other):
8667 
    return not (self == other)
8668 
 
132 ashish 8669 
class getTransactionsForShoppingCartId_args:
8670 
  """
8671 
  Attributes:
8672 
   - shoppingCartId
8673 
  """
8674 
 
8675 
  thrift_spec = (
8676 
    None, # 0
8677 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8678 
  )
8679 
 
8680 
  def __init__(self, shoppingCartId=None,):
8681 
    self.shoppingCartId = shoppingCartId
8682 
 
8683 
  def read(self, iprot):
8684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8686 
      return
8687 
    iprot.readStructBegin()
8688 
    while True:
8689 
      (fname, ftype, fid) = iprot.readFieldBegin()
8690 
      if ftype == TType.STOP:
8691 
        break
8692 
      if fid == 1:
8693 
        if ftype == TType.I64:
8694 
          self.shoppingCartId = iprot.readI64();
8695 
        else:
8696 
          iprot.skip(ftype)
8697 
      else:
8698 
        iprot.skip(ftype)
8699 
      iprot.readFieldEnd()
8700 
    iprot.readStructEnd()
8701 
 
8702 
  def write(self, oprot):
8703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8705 
      return
8706 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8707 
    if self.shoppingCartId is not None:
132 ashish 8708 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8709 
      oprot.writeI64(self.shoppingCartId)
8710 
      oprot.writeFieldEnd()
8711 
    oprot.writeFieldStop()
8712 
    oprot.writeStructEnd()
8713 
 
3431 rajveer 8714 
  def validate(self):
8715 
    return
8716 
 
8717 
 
132 ashish 8718 
  def __repr__(self):
8719 
    L = ['%s=%r' % (key, value)
8720 
      for key, value in self.__dict__.iteritems()]
8721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8722 
 
8723 
  def __eq__(self, other):
8724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8725 
 
8726 
  def __ne__(self, other):
8727 
    return not (self == other)
8728 
 
8729 
class getTransactionsForShoppingCartId_result:
8730 
  """
8731 
  Attributes:
8732 
   - success
8733 
   - ex
8734 
  """
8735 
 
8736 
  thrift_spec = (
8737 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8739 
  )
8740 
 
8741 
  def __init__(self, success=None, ex=None,):
8742 
    self.success = success
8743 
    self.ex = ex
8744 
 
8745 
  def read(self, iprot):
8746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8748 
      return
8749 
    iprot.readStructBegin()
8750 
    while True:
8751 
      (fname, ftype, fid) = iprot.readFieldBegin()
8752 
      if ftype == TType.STOP:
8753 
        break
8754 
      if fid == 0:
8755 
        if ftype == TType.LIST:
8756 
          self.success = []
6031 rajveer 8757 
          (_etype73, _size70) = iprot.readListBegin()
8758 
          for _i74 in xrange(_size70):
8759 
            _elem75 = Transaction()
8760 
            _elem75.read(iprot)
8761 
            self.success.append(_elem75)
132 ashish 8762 
          iprot.readListEnd()
8763 
        else:
8764 
          iprot.skip(ftype)
8765 
      elif fid == 1:
8766 
        if ftype == TType.STRUCT:
8767 
          self.ex = TransactionServiceException()
8768 
          self.ex.read(iprot)
8769 
        else:
8770 
          iprot.skip(ftype)
8771 
      else:
8772 
        iprot.skip(ftype)
8773 
      iprot.readFieldEnd()
8774 
    iprot.readStructEnd()
8775 
 
8776 
  def write(self, oprot):
8777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8779 
      return
8780 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8781 
    if self.success is not None:
132 ashish 8782 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8783 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8784 
      for iter76 in self.success:
8785 
        iter76.write(oprot)
132 ashish 8786 
      oprot.writeListEnd()
8787 
      oprot.writeFieldEnd()
3431 rajveer 8788 
    if self.ex is not None:
132 ashish 8789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8790 
      self.ex.write(oprot)
8791 
      oprot.writeFieldEnd()
8792 
    oprot.writeFieldStop()
8793 
    oprot.writeStructEnd()
8794 
 
3431 rajveer 8795 
  def validate(self):
8796 
    return
8797 
 
8798 
 
132 ashish 8799 
  def __repr__(self):
8800 
    L = ['%s=%r' % (key, value)
8801 
      for key, value in self.__dict__.iteritems()]
8802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8803 
 
8804 
  def __eq__(self, other):
8805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8806 
 
8807 
  def __ne__(self, other):
8808 
    return not (self == other)
8809 
 
94 ashish 8810 
class getTransactionStatus_args:
8811 
  """
8812 
  Attributes:
8813 
   - transactionId
8814 
  """
8815 
 
8816 
  thrift_spec = (
8817 
    None, # 0
8818 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8819 
  )
8820 
 
8821 
  def __init__(self, transactionId=None,):
8822 
    self.transactionId = transactionId
8823 
 
8824 
  def read(self, iprot):
8825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8827 
      return
8828 
    iprot.readStructBegin()
8829 
    while True:
8830 
      (fname, ftype, fid) = iprot.readFieldBegin()
8831 
      if ftype == TType.STOP:
8832 
        break
8833 
      if fid == 1:
8834 
        if ftype == TType.I64:
8835 
          self.transactionId = iprot.readI64();
8836 
        else:
8837 
          iprot.skip(ftype)
8838 
      else:
8839 
        iprot.skip(ftype)
8840 
      iprot.readFieldEnd()
8841 
    iprot.readStructEnd()
8842 
 
8843 
  def write(self, oprot):
8844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8846 
      return
8847 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8848 
    if self.transactionId is not None:
94 ashish 8849 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8850 
      oprot.writeI64(self.transactionId)
8851 
      oprot.writeFieldEnd()
8852 
    oprot.writeFieldStop()
8853 
    oprot.writeStructEnd()
8854 
 
3431 rajveer 8855 
  def validate(self):
8856 
    return
8857 
 
8858 
 
94 ashish 8859 
  def __repr__(self):
8860 
    L = ['%s=%r' % (key, value)
8861 
      for key, value in self.__dict__.iteritems()]
8862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8863 
 
8864 
  def __eq__(self, other):
8865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8866 
 
8867 
  def __ne__(self, other):
8868 
    return not (self == other)
8869 
 
8870 
class getTransactionStatus_result:
8871 
  """
8872 
  Attributes:
8873 
   - success
8874 
   - ex
8875 
  """
8876 
 
8877 
  thrift_spec = (
8878 
    (0, TType.I32, 'success', None, None, ), # 0
8879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8880 
  )
8881 
 
8882 
  def __init__(self, success=None, ex=None,):
8883 
    self.success = success
8884 
    self.ex = ex
8885 
 
8886 
  def read(self, iprot):
8887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8889 
      return
8890 
    iprot.readStructBegin()
8891 
    while True:
8892 
      (fname, ftype, fid) = iprot.readFieldBegin()
8893 
      if ftype == TType.STOP:
8894 
        break
8895 
      if fid == 0:
8896 
        if ftype == TType.I32:
8897 
          self.success = iprot.readI32();
8898 
        else:
8899 
          iprot.skip(ftype)
8900 
      elif fid == 1:
8901 
        if ftype == TType.STRUCT:
8902 
          self.ex = TransactionServiceException()
8903 
          self.ex.read(iprot)
8904 
        else:
8905 
          iprot.skip(ftype)
8906 
      else:
8907 
        iprot.skip(ftype)
8908 
      iprot.readFieldEnd()
8909 
    iprot.readStructEnd()
8910 
 
8911 
  def write(self, oprot):
8912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8914 
      return
8915 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8916 
    if self.success is not None:
94 ashish 8917 
      oprot.writeFieldBegin('success', TType.I32, 0)
8918 
      oprot.writeI32(self.success)
8919 
      oprot.writeFieldEnd()
3431 rajveer 8920 
    if self.ex is not None:
94 ashish 8921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8922 
      self.ex.write(oprot)
8923 
      oprot.writeFieldEnd()
8924 
    oprot.writeFieldStop()
8925 
    oprot.writeStructEnd()
8926 
 
3431 rajveer 8927 
  def validate(self):
8928 
    return
8929 
 
8930 
 
94 ashish 8931 
  def __repr__(self):
8932 
    L = ['%s=%r' % (key, value)
8933 
      for key, value in self.__dict__.iteritems()]
8934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8935 
 
8936 
  def __eq__(self, other):
8937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8938 
 
8939 
  def __ne__(self, other):
8940 
    return not (self == other)
8941 
 
8942 
class changeTransactionStatus_args:
8943 
  """
8944 
  Attributes:
8945 
   - transactionId
8946 
   - status
8947 
   - description
5527 anupam.sin 8948 
   - pickUp
8949 
   - orderType
94 ashish 8950 
  """
8951 
 
8952 
  thrift_spec = (
8953 
    None, # 0
8954 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8955 
    (2, TType.I32, 'status', None, None, ), # 2
8956 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8957 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8958 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8959 
  )
8960 
 
5527 anupam.sin 8961 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8962 
    self.transactionId = transactionId
8963 
    self.status = status
8964 
    self.description = description
5527 anupam.sin 8965 
    self.pickUp = pickUp
8966 
    self.orderType = orderType
94 ashish 8967 
 
8968 
  def read(self, iprot):
8969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8971 
      return
8972 
    iprot.readStructBegin()
8973 
    while True:
8974 
      (fname, ftype, fid) = iprot.readFieldBegin()
8975 
      if ftype == TType.STOP:
8976 
        break
8977 
      if fid == 1:
8978 
        if ftype == TType.I64:
8979 
          self.transactionId = iprot.readI64();
8980 
        else:
8981 
          iprot.skip(ftype)
8982 
      elif fid == 2:
8983 
        if ftype == TType.I32:
8984 
          self.status = iprot.readI32();
8985 
        else:
8986 
          iprot.skip(ftype)
8987 
      elif fid == 3:
8988 
        if ftype == TType.STRING:
8989 
          self.description = iprot.readString();
8990 
        else:
8991 
          iprot.skip(ftype)
5387 rajveer 8992 
      elif fid == 4:
5527 anupam.sin 8993 
        if ftype == TType.I64:
8994 
          self.pickUp = iprot.readI64();
5387 rajveer 8995 
        else:
8996 
          iprot.skip(ftype)
5527 anupam.sin 8997 
      elif fid == 5:
8998 
        if ftype == TType.I32:
8999 
          self.orderType = iprot.readI32();
9000 
        else:
9001 
          iprot.skip(ftype)
94 ashish 9002 
      else:
9003 
        iprot.skip(ftype)
9004 
      iprot.readFieldEnd()
9005 
    iprot.readStructEnd()
9006 
 
9007 
  def write(self, oprot):
9008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9010 
      return
9011 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9012 
    if self.transactionId is not None:
94 ashish 9013 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9014 
      oprot.writeI64(self.transactionId)
9015 
      oprot.writeFieldEnd()
3431 rajveer 9016 
    if self.status is not None:
94 ashish 9017 
      oprot.writeFieldBegin('status', TType.I32, 2)
9018 
      oprot.writeI32(self.status)
9019 
      oprot.writeFieldEnd()
3431 rajveer 9020 
    if self.description is not None:
94 ashish 9021 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9022 
      oprot.writeString(self.description)
9023 
      oprot.writeFieldEnd()
5527 anupam.sin 9024 
    if self.pickUp is not None:
9025 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9026 
      oprot.writeI64(self.pickUp)
5387 rajveer 9027 
      oprot.writeFieldEnd()
5527 anupam.sin 9028 
    if self.orderType is not None:
9029 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9030 
      oprot.writeI32(self.orderType)
9031 
      oprot.writeFieldEnd()
94 ashish 9032 
    oprot.writeFieldStop()
9033 
    oprot.writeStructEnd()
9034 
 
3431 rajveer 9035 
  def validate(self):
9036 
    return
9037 
 
9038 
 
94 ashish 9039 
  def __repr__(self):
9040 
    L = ['%s=%r' % (key, value)
9041 
      for key, value in self.__dict__.iteritems()]
9042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9043 
 
9044 
  def __eq__(self, other):
9045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9046 
 
9047 
  def __ne__(self, other):
9048 
    return not (self == other)
9049 
 
9050 
class changeTransactionStatus_result:
9051 
  """
9052 
  Attributes:
9053 
   - success
9054 
   - ex
9055 
  """
9056 
 
9057 
  thrift_spec = (
9058 
    (0, TType.BOOL, 'success', None, None, ), # 0
9059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9060 
  )
9061 
 
9062 
  def __init__(self, success=None, ex=None,):
9063 
    self.success = success
9064 
    self.ex = ex
9065 
 
9066 
  def read(self, iprot):
9067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9069 
      return
9070 
    iprot.readStructBegin()
9071 
    while True:
9072 
      (fname, ftype, fid) = iprot.readFieldBegin()
9073 
      if ftype == TType.STOP:
9074 
        break
9075 
      if fid == 0:
9076 
        if ftype == TType.BOOL:
9077 
          self.success = iprot.readBool();
9078 
        else:
9079 
          iprot.skip(ftype)
9080 
      elif fid == 1:
9081 
        if ftype == TType.STRUCT:
9082 
          self.ex = TransactionServiceException()
9083 
          self.ex.read(iprot)
9084 
        else:
9085 
          iprot.skip(ftype)
9086 
      else:
9087 
        iprot.skip(ftype)
9088 
      iprot.readFieldEnd()
9089 
    iprot.readStructEnd()
9090 
 
9091 
  def write(self, oprot):
9092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9094 
      return
9095 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9096 
    if self.success is not None:
94 ashish 9097 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9098 
      oprot.writeBool(self.success)
9099 
      oprot.writeFieldEnd()
3431 rajveer 9100 
    if self.ex is not None:
94 ashish 9101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9102 
      self.ex.write(oprot)
9103 
      oprot.writeFieldEnd()
9104 
    oprot.writeFieldStop()
9105 
    oprot.writeStructEnd()
9106 
 
3431 rajveer 9107 
  def validate(self):
9108 
    return
9109 
 
9110 
 
94 ashish 9111 
  def __repr__(self):
9112 
    L = ['%s=%r' % (key, value)
9113 
      for key, value in self.__dict__.iteritems()]
9114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9115 
 
9116 
  def __eq__(self, other):
9117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9118 
 
9119 
  def __ne__(self, other):
9120 
    return not (self == other)
9121 
 
1398 varun.gupt 9122 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9123 
  """
9124 
  Attributes:
9125 
   - transactionId
9126 
  """
9127 
 
9128 
  thrift_spec = (
9129 
    None, # 0
9130 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9131 
  )
9132 
 
9133 
  def __init__(self, transactionId=None,):
9134 
    self.transactionId = transactionId
9135 
 
9136 
  def read(self, iprot):
9137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9139 
      return
9140 
    iprot.readStructBegin()
9141 
    while True:
9142 
      (fname, ftype, fid) = iprot.readFieldBegin()
9143 
      if ftype == TType.STOP:
9144 
        break
9145 
      if fid == 1:
9146 
        if ftype == TType.I64:
9147 
          self.transactionId = iprot.readI64();
9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
1398 varun.gupt 9159 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9160 
    if self.transactionId is not None:
1382 varun.gupt 9161 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9162 
      oprot.writeI64(self.transactionId)
9163 
      oprot.writeFieldEnd()
9164 
    oprot.writeFieldStop()
9165 
    oprot.writeStructEnd()
9166 
 
3431 rajveer 9167 
  def validate(self):
9168 
    return
9169 
 
9170 
 
1382 varun.gupt 9171 
  def __repr__(self):
9172 
    L = ['%s=%r' % (key, value)
9173 
      for key, value in self.__dict__.iteritems()]
9174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9175 
 
9176 
  def __eq__(self, other):
9177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9178 
 
9179 
  def __ne__(self, other):
9180 
    return not (self == other)
9181 
 
1398 varun.gupt 9182 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9183 
  """
9184 
  Attributes:
9185 
   - success
9186 
   - ex
9187 
  """
9188 
 
9189 
  thrift_spec = (
9190 
    (0, TType.BOOL, 'success', None, None, ), # 0
9191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9192 
  )
9193 
 
9194 
  def __init__(self, success=None, ex=None,):
9195 
    self.success = success
9196 
    self.ex = ex
9197 
 
9198 
  def read(self, iprot):
9199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9201 
      return
9202 
    iprot.readStructBegin()
9203 
    while True:
9204 
      (fname, ftype, fid) = iprot.readFieldBegin()
9205 
      if ftype == TType.STOP:
9206 
        break
9207 
      if fid == 0:
9208 
        if ftype == TType.BOOL:
9209 
          self.success = iprot.readBool();
9210 
        else:
9211 
          iprot.skip(ftype)
9212 
      elif fid == 1:
9213 
        if ftype == TType.STRUCT:
9214 
          self.ex = TransactionServiceException()
9215 
          self.ex.read(iprot)
9216 
        else:
9217 
          iprot.skip(ftype)
9218 
      else:
9219 
        iprot.skip(ftype)
9220 
      iprot.readFieldEnd()
9221 
    iprot.readStructEnd()
9222 
 
9223 
  def write(self, oprot):
9224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9226 
      return
1398 varun.gupt 9227 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9228 
    if self.success is not None:
1382 varun.gupt 9229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9230 
      oprot.writeBool(self.success)
9231 
      oprot.writeFieldEnd()
3431 rajveer 9232 
    if self.ex is not None:
1382 varun.gupt 9233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9234 
      self.ex.write(oprot)
9235 
      oprot.writeFieldEnd()
9236 
    oprot.writeFieldStop()
9237 
    oprot.writeStructEnd()
9238 
 
3431 rajveer 9239 
  def validate(self):
9240 
    return
9241 
 
9242 
 
1382 varun.gupt 9243 
  def __repr__(self):
9244 
    L = ['%s=%r' % (key, value)
9245 
      for key, value in self.__dict__.iteritems()]
9246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9247 
 
9248 
  def __eq__(self, other):
9249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9250 
 
9251 
  def __ne__(self, other):
9252 
    return not (self == other)
9253 
 
483 rajveer 9254 
class getAllOrders_args:
94 ashish 9255 
  """
9256 
  Attributes:
4801 anupam.sin 9257 
   - statuses
483 rajveer 9258 
   - from_date
9259 
   - to_date
9260 
   - warehouse_id
94 ashish 9261 
  """
9262 
 
9263 
  thrift_spec = (
9264 
    None, # 0
4801 anupam.sin 9265 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9266 
    (2, TType.I64, 'from_date', None, None, ), # 2
9267 
    (3, TType.I64, 'to_date', None, None, ), # 3
9268 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9269 
  )
9270 
 
4801 anupam.sin 9271 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9272 
    self.statuses = statuses
483 rajveer 9273 
    self.from_date = from_date
9274 
    self.to_date = to_date
9275 
    self.warehouse_id = warehouse_id
94 ashish 9276 
 
9277 
  def read(self, iprot):
9278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9280 
      return
9281 
    iprot.readStructBegin()
9282 
    while True:
9283 
      (fname, ftype, fid) = iprot.readFieldBegin()
9284 
      if ftype == TType.STOP:
9285 
        break
9286 
      if fid == 1:
4801 anupam.sin 9287 
        if ftype == TType.LIST:
9288 
          self.statuses = []
6031 rajveer 9289 
          (_etype80, _size77) = iprot.readListBegin()
9290 
          for _i81 in xrange(_size77):
9291 
            _elem82 = iprot.readI32();
9292 
            self.statuses.append(_elem82)
4801 anupam.sin 9293 
          iprot.readListEnd()
94 ashish 9294 
        else:
9295 
          iprot.skip(ftype)
483 rajveer 9296 
      elif fid == 2:
9297 
        if ftype == TType.I64:
9298 
          self.from_date = iprot.readI64();
94 ashish 9299 
        else:
9300 
          iprot.skip(ftype)
483 rajveer 9301 
      elif fid == 3:
9302 
        if ftype == TType.I64:
9303 
          self.to_date = iprot.readI64();
94 ashish 9304 
        else:
9305 
          iprot.skip(ftype)
483 rajveer 9306 
      elif fid == 4:
94 ashish 9307 
        if ftype == TType.I64:
483 rajveer 9308 
          self.warehouse_id = iprot.readI64();
94 ashish 9309 
        else:
9310 
          iprot.skip(ftype)
9311 
      else:
9312 
        iprot.skip(ftype)
9313 
      iprot.readFieldEnd()
9314 
    iprot.readStructEnd()
9315 
 
9316 
  def write(self, oprot):
9317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9319 
      return
483 rajveer 9320 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9321 
    if self.statuses is not None:
9322 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9323 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9324 
      for iter83 in self.statuses:
9325 
        oprot.writeI32(iter83)
4801 anupam.sin 9326 
      oprot.writeListEnd()
94 ashish 9327 
      oprot.writeFieldEnd()
3431 rajveer 9328 
    if self.from_date is not None:
483 rajveer 9329 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9330 
      oprot.writeI64(self.from_date)
94 ashish 9331 
      oprot.writeFieldEnd()
3431 rajveer 9332 
    if self.to_date is not None:
483 rajveer 9333 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9334 
      oprot.writeI64(self.to_date)
94 ashish 9335 
      oprot.writeFieldEnd()
3431 rajveer 9336 
    if self.warehouse_id is not None:
483 rajveer 9337 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9338 
      oprot.writeI64(self.warehouse_id)
94 ashish 9339 
      oprot.writeFieldEnd()
9340 
    oprot.writeFieldStop()
9341 
    oprot.writeStructEnd()
9342 
 
3431 rajveer 9343 
  def validate(self):
9344 
    return
9345 
 
9346 
 
94 ashish 9347 
  def __repr__(self):
9348 
    L = ['%s=%r' % (key, value)
9349 
      for key, value in self.__dict__.iteritems()]
9350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9351 
 
9352 
  def __eq__(self, other):
9353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9354 
 
9355 
  def __ne__(self, other):
9356 
    return not (self == other)
9357 
 
483 rajveer 9358 
class getAllOrders_result:
94 ashish 9359 
  """
9360 
  Attributes:
9361 
   - success
9362 
   - ex
9363 
  """
9364 
 
9365 
  thrift_spec = (
483 rajveer 9366 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9368 
  )
9369 
 
9370 
  def __init__(self, success=None, ex=None,):
9371 
    self.success = success
9372 
    self.ex = ex
9373 
 
9374 
  def read(self, iprot):
9375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9377 
      return
9378 
    iprot.readStructBegin()
9379 
    while True:
9380 
      (fname, ftype, fid) = iprot.readFieldBegin()
9381 
      if ftype == TType.STOP:
9382 
        break
9383 
      if fid == 0:
483 rajveer 9384 
        if ftype == TType.LIST:
9385 
          self.success = []
6031 rajveer 9386 
          (_etype87, _size84) = iprot.readListBegin()
9387 
          for _i88 in xrange(_size84):
9388 
            _elem89 = Order()
9389 
            _elem89.read(iprot)
9390 
            self.success.append(_elem89)
483 rajveer 9391 
          iprot.readListEnd()
94 ashish 9392 
        else:
9393 
          iprot.skip(ftype)
9394 
      elif fid == 1:
9395 
        if ftype == TType.STRUCT:
9396 
          self.ex = TransactionServiceException()
9397 
          self.ex.read(iprot)
9398 
        else:
9399 
          iprot.skip(ftype)
9400 
      else:
9401 
        iprot.skip(ftype)
9402 
      iprot.readFieldEnd()
9403 
    iprot.readStructEnd()
9404 
 
9405 
  def write(self, oprot):
9406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9408 
      return
483 rajveer 9409 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9410 
    if self.success is not None:
483 rajveer 9411 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9412 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9413 
      for iter90 in self.success:
9414 
        iter90.write(oprot)
483 rajveer 9415 
      oprot.writeListEnd()
94 ashish 9416 
      oprot.writeFieldEnd()
3431 rajveer 9417 
    if self.ex is not None:
94 ashish 9418 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9419 
      self.ex.write(oprot)
9420 
      oprot.writeFieldEnd()
9421 
    oprot.writeFieldStop()
9422 
    oprot.writeStructEnd()
9423 
 
3431 rajveer 9424 
  def validate(self):
9425 
    return
9426 
 
9427 
 
94 ashish 9428 
  def __repr__(self):
9429 
    L = ['%s=%r' % (key, value)
9430 
      for key, value in self.__dict__.iteritems()]
9431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9432 
 
9433 
  def __eq__(self, other):
9434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9435 
 
9436 
  def __ne__(self, other):
9437 
    return not (self == other)
9438 
 
4133 chandransh 9439 
class getOrdersInBatch_args:
9440 
  """
9441 
  Attributes:
9442 
   - statuses
9443 
   - offset
9444 
   - limit
9445 
   - warehouse_id
9446 
  """
9447 
 
9448 
  thrift_spec = (
9449 
    None, # 0
9450 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9451 
    (2, TType.I64, 'offset', None, None, ), # 2
9452 
    (3, TType.I64, 'limit', None, None, ), # 3
9453 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9454 
  )
9455 
 
9456 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9457 
    self.statuses = statuses
9458 
    self.offset = offset
9459 
    self.limit = limit
9460 
    self.warehouse_id = warehouse_id
9461 
 
9462 
  def read(self, iprot):
9463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9465 
      return
9466 
    iprot.readStructBegin()
9467 
    while True:
9468 
      (fname, ftype, fid) = iprot.readFieldBegin()
9469 
      if ftype == TType.STOP:
9470 
        break
9471 
      if fid == 1:
9472 
        if ftype == TType.LIST:
9473 
          self.statuses = []
6031 rajveer 9474 
          (_etype94, _size91) = iprot.readListBegin()
9475 
          for _i95 in xrange(_size91):
9476 
            _elem96 = iprot.readI32();
9477 
            self.statuses.append(_elem96)
4133 chandransh 9478 
          iprot.readListEnd()
9479 
        else:
9480 
          iprot.skip(ftype)
9481 
      elif fid == 2:
9482 
        if ftype == TType.I64:
9483 
          self.offset = iprot.readI64();
9484 
        else:
9485 
          iprot.skip(ftype)
9486 
      elif fid == 3:
9487 
        if ftype == TType.I64:
9488 
          self.limit = iprot.readI64();
9489 
        else:
9490 
          iprot.skip(ftype)
9491 
      elif fid == 4:
9492 
        if ftype == TType.I64:
9493 
          self.warehouse_id = iprot.readI64();
9494 
        else:
9495 
          iprot.skip(ftype)
9496 
      else:
9497 
        iprot.skip(ftype)
9498 
      iprot.readFieldEnd()
9499 
    iprot.readStructEnd()
9500 
 
9501 
  def write(self, oprot):
9502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9504 
      return
9505 
    oprot.writeStructBegin('getOrdersInBatch_args')
9506 
    if self.statuses is not None:
9507 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9508 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9509 
      for iter97 in self.statuses:
9510 
        oprot.writeI32(iter97)
4133 chandransh 9511 
      oprot.writeListEnd()
9512 
      oprot.writeFieldEnd()
9513 
    if self.offset is not None:
9514 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9515 
      oprot.writeI64(self.offset)
9516 
      oprot.writeFieldEnd()
9517 
    if self.limit is not None:
9518 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9519 
      oprot.writeI64(self.limit)
9520 
      oprot.writeFieldEnd()
9521 
    if self.warehouse_id is not None:
9522 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9523 
      oprot.writeI64(self.warehouse_id)
9524 
      oprot.writeFieldEnd()
9525 
    oprot.writeFieldStop()
9526 
    oprot.writeStructEnd()
9527 
 
9528 
  def validate(self):
9529 
    return
9530 
 
9531 
 
9532 
  def __repr__(self):
9533 
    L = ['%s=%r' % (key, value)
9534 
      for key, value in self.__dict__.iteritems()]
9535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9536 
 
9537 
  def __eq__(self, other):
9538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9539 
 
9540 
  def __ne__(self, other):
9541 
    return not (self == other)
9542 
 
9543 
class getOrdersInBatch_result:
9544 
  """
9545 
  Attributes:
9546 
   - success
9547 
   - ex
9548 
  """
9549 
 
9550 
  thrift_spec = (
9551 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9553 
  )
9554 
 
9555 
  def __init__(self, success=None, ex=None,):
9556 
    self.success = success
9557 
    self.ex = ex
9558 
 
9559 
  def read(self, iprot):
9560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9562 
      return
9563 
    iprot.readStructBegin()
9564 
    while True:
9565 
      (fname, ftype, fid) = iprot.readFieldBegin()
9566 
      if ftype == TType.STOP:
9567 
        break
9568 
      if fid == 0:
9569 
        if ftype == TType.LIST:
9570 
          self.success = []
6031 rajveer 9571 
          (_etype101, _size98) = iprot.readListBegin()
9572 
          for _i102 in xrange(_size98):
9573 
            _elem103 = Order()
9574 
            _elem103.read(iprot)
9575 
            self.success.append(_elem103)
4133 chandransh 9576 
          iprot.readListEnd()
9577 
        else:
9578 
          iprot.skip(ftype)
9579 
      elif fid == 1:
9580 
        if ftype == TType.STRUCT:
9581 
          self.ex = TransactionServiceException()
9582 
          self.ex.read(iprot)
9583 
        else:
9584 
          iprot.skip(ftype)
9585 
      else:
9586 
        iprot.skip(ftype)
9587 
      iprot.readFieldEnd()
9588 
    iprot.readStructEnd()
9589 
 
9590 
  def write(self, oprot):
9591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9593 
      return
9594 
    oprot.writeStructBegin('getOrdersInBatch_result')
9595 
    if self.success is not None:
9596 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9597 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9598 
      for iter104 in self.success:
9599 
        iter104.write(oprot)
4133 chandransh 9600 
      oprot.writeListEnd()
9601 
      oprot.writeFieldEnd()
9602 
    if self.ex is not None:
9603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9604 
      self.ex.write(oprot)
9605 
      oprot.writeFieldEnd()
9606 
    oprot.writeFieldStop()
9607 
    oprot.writeStructEnd()
9608 
 
9609 
  def validate(self):
9610 
    return
9611 
 
9612 
 
9613 
  def __repr__(self):
9614 
    L = ['%s=%r' % (key, value)
9615 
      for key, value in self.__dict__.iteritems()]
9616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9617 
 
9618 
  def __eq__(self, other):
9619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9620 
 
9621 
  def __ne__(self, other):
9622 
    return not (self == other)
9623 
 
9624 
class getOrderCount_args:
9625 
  """
9626 
  Attributes:
9627 
   - statuses
9628 
   - warehouseId
9629 
  """
9630 
 
9631 
  thrift_spec = (
9632 
    None, # 0
9633 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9634 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9635 
  )
9636 
 
9637 
  def __init__(self, statuses=None, warehouseId=None,):
9638 
    self.statuses = statuses
9639 
    self.warehouseId = warehouseId
9640 
 
9641 
  def read(self, iprot):
9642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9644 
      return
9645 
    iprot.readStructBegin()
9646 
    while True:
9647 
      (fname, ftype, fid) = iprot.readFieldBegin()
9648 
      if ftype == TType.STOP:
9649 
        break
9650 
      if fid == 1:
9651 
        if ftype == TType.LIST:
9652 
          self.statuses = []
6031 rajveer 9653 
          (_etype108, _size105) = iprot.readListBegin()
9654 
          for _i109 in xrange(_size105):
9655 
            _elem110 = iprot.readI32();
9656 
            self.statuses.append(_elem110)
4133 chandransh 9657 
          iprot.readListEnd()
9658 
        else:
9659 
          iprot.skip(ftype)
9660 
      elif fid == 2:
9661 
        if ftype == TType.I64:
9662 
          self.warehouseId = iprot.readI64();
9663 
        else:
9664 
          iprot.skip(ftype)
9665 
      else:
9666 
        iprot.skip(ftype)
9667 
      iprot.readFieldEnd()
9668 
    iprot.readStructEnd()
9669 
 
9670 
  def write(self, oprot):
9671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9673 
      return
9674 
    oprot.writeStructBegin('getOrderCount_args')
9675 
    if self.statuses is not None:
9676 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9677 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9678 
      for iter111 in self.statuses:
9679 
        oprot.writeI32(iter111)
4133 chandransh 9680 
      oprot.writeListEnd()
9681 
      oprot.writeFieldEnd()
9682 
    if self.warehouseId is not None:
9683 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9684 
      oprot.writeI64(self.warehouseId)
9685 
      oprot.writeFieldEnd()
9686 
    oprot.writeFieldStop()
9687 
    oprot.writeStructEnd()
9688 
 
9689 
  def validate(self):
9690 
    return
9691 
 
9692 
 
9693 
  def __repr__(self):
9694 
    L = ['%s=%r' % (key, value)
9695 
      for key, value in self.__dict__.iteritems()]
9696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9697 
 
9698 
  def __eq__(self, other):
9699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9700 
 
9701 
  def __ne__(self, other):
9702 
    return not (self == other)
9703 
 
9704 
class getOrderCount_result:
9705 
  """
9706 
  Attributes:
9707 
   - success
9708 
   - ex
9709 
  """
9710 
 
9711 
  thrift_spec = (
9712 
    (0, TType.I32, 'success', None, None, ), # 0
9713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9714 
  )
9715 
 
9716 
  def __init__(self, success=None, ex=None,):
9717 
    self.success = success
9718 
    self.ex = ex
9719 
 
9720 
  def read(self, iprot):
9721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9723 
      return
9724 
    iprot.readStructBegin()
9725 
    while True:
9726 
      (fname, ftype, fid) = iprot.readFieldBegin()
9727 
      if ftype == TType.STOP:
9728 
        break
9729 
      if fid == 0:
9730 
        if ftype == TType.I32:
9731 
          self.success = iprot.readI32();
9732 
        else:
9733 
          iprot.skip(ftype)
9734 
      elif fid == 1:
9735 
        if ftype == TType.STRUCT:
9736 
          self.ex = TransactionServiceException()
9737 
          self.ex.read(iprot)
9738 
        else:
9739 
          iprot.skip(ftype)
9740 
      else:
9741 
        iprot.skip(ftype)
9742 
      iprot.readFieldEnd()
9743 
    iprot.readStructEnd()
9744 
 
9745 
  def write(self, oprot):
9746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9748 
      return
9749 
    oprot.writeStructBegin('getOrderCount_result')
9750 
    if self.success is not None:
9751 
      oprot.writeFieldBegin('success', TType.I32, 0)
9752 
      oprot.writeI32(self.success)
9753 
      oprot.writeFieldEnd()
9754 
    if self.ex is not None:
9755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9756 
      self.ex.write(oprot)
9757 
      oprot.writeFieldEnd()
9758 
    oprot.writeFieldStop()
9759 
    oprot.writeStructEnd()
9760 
 
9761 
  def validate(self):
9762 
    return
9763 
 
9764 
 
9765 
  def __repr__(self):
9766 
    L = ['%s=%r' % (key, value)
9767 
      for key, value in self.__dict__.iteritems()]
9768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9769 
 
9770 
  def __eq__(self, other):
9771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9772 
 
9773 
  def __ne__(self, other):
9774 
    return not (self == other)
9775 
 
999 varun.gupt 9776 
class getOrdersByBillingDate_args:
9777 
  """
9778 
  Attributes:
9779 
   - status
9780 
   - start_billing_date
9781 
   - end_billing_date
9782 
   - warehouse_id
9783 
  """
9784 
 
9785 
  thrift_spec = (
9786 
    None, # 0
9787 
    (1, TType.I32, 'status', None, None, ), # 1
9788 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9789 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9790 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9791 
  )
9792 
 
9793 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9794 
    self.status = status
9795 
    self.start_billing_date = start_billing_date
9796 
    self.end_billing_date = end_billing_date
9797 
    self.warehouse_id = warehouse_id
9798 
 
9799 
  def read(self, iprot):
9800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9802 
      return
9803 
    iprot.readStructBegin()
9804 
    while True:
9805 
      (fname, ftype, fid) = iprot.readFieldBegin()
9806 
      if ftype == TType.STOP:
9807 
        break
9808 
      if fid == 1:
9809 
        if ftype == TType.I32:
9810 
          self.status = iprot.readI32();
9811 
        else:
9812 
          iprot.skip(ftype)
9813 
      elif fid == 2:
9814 
        if ftype == TType.I64:
9815 
          self.start_billing_date = iprot.readI64();
9816 
        else:
9817 
          iprot.skip(ftype)
9818 
      elif fid == 3:
9819 
        if ftype == TType.I64:
9820 
          self.end_billing_date = iprot.readI64();
9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      elif fid == 4:
9824 
        if ftype == TType.I64:
9825 
          self.warehouse_id = iprot.readI64();
9826 
        else:
9827 
          iprot.skip(ftype)
9828 
      else:
9829 
        iprot.skip(ftype)
9830 
      iprot.readFieldEnd()
9831 
    iprot.readStructEnd()
9832 
 
9833 
  def write(self, oprot):
9834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9836 
      return
9837 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9838 
    if self.status is not None:
999 varun.gupt 9839 
      oprot.writeFieldBegin('status', TType.I32, 1)
9840 
      oprot.writeI32(self.status)
9841 
      oprot.writeFieldEnd()
3431 rajveer 9842 
    if self.start_billing_date is not None:
999 varun.gupt 9843 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9844 
      oprot.writeI64(self.start_billing_date)
9845 
      oprot.writeFieldEnd()
3431 rajveer 9846 
    if self.end_billing_date is not None:
999 varun.gupt 9847 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9848 
      oprot.writeI64(self.end_billing_date)
9849 
      oprot.writeFieldEnd()
3431 rajveer 9850 
    if self.warehouse_id is not None:
999 varun.gupt 9851 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9852 
      oprot.writeI64(self.warehouse_id)
9853 
      oprot.writeFieldEnd()
9854 
    oprot.writeFieldStop()
9855 
    oprot.writeStructEnd()
9856 
 
3431 rajveer 9857 
  def validate(self):
9858 
    return
9859 
 
9860 
 
999 varun.gupt 9861 
  def __repr__(self):
9862 
    L = ['%s=%r' % (key, value)
9863 
      for key, value in self.__dict__.iteritems()]
9864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9865 
 
9866 
  def __eq__(self, other):
9867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9868 
 
9869 
  def __ne__(self, other):
9870 
    return not (self == other)
9871 
 
9872 
class getOrdersByBillingDate_result:
9873 
  """
9874 
  Attributes:
9875 
   - success
9876 
   - ex
9877 
  """
9878 
 
9879 
  thrift_spec = (
9880 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9882 
  )
9883 
 
9884 
  def __init__(self, success=None, ex=None,):
9885 
    self.success = success
9886 
    self.ex = ex
9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 0:
9898 
        if ftype == TType.LIST:
9899 
          self.success = []
6031 rajveer 9900 
          (_etype115, _size112) = iprot.readListBegin()
9901 
          for _i116 in xrange(_size112):
9902 
            _elem117 = Order()
9903 
            _elem117.read(iprot)
9904 
            self.success.append(_elem117)
999 varun.gupt 9905 
          iprot.readListEnd()
9906 
        else:
9907 
          iprot.skip(ftype)
9908 
      elif fid == 1:
9909 
        if ftype == TType.STRUCT:
9910 
          self.ex = TransactionServiceException()
9911 
          self.ex.read(iprot)
9912 
        else:
9913 
          iprot.skip(ftype)
9914 
      else:
9915 
        iprot.skip(ftype)
9916 
      iprot.readFieldEnd()
9917 
    iprot.readStructEnd()
9918 
 
9919 
  def write(self, oprot):
9920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9922 
      return
9923 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9924 
    if self.success is not None:
999 varun.gupt 9925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9927 
      for iter118 in self.success:
9928 
        iter118.write(oprot)
999 varun.gupt 9929 
      oprot.writeListEnd()
9930 
      oprot.writeFieldEnd()
3431 rajveer 9931 
    if self.ex is not None:
999 varun.gupt 9932 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9933 
      self.ex.write(oprot)
9934 
      oprot.writeFieldEnd()
9935 
    oprot.writeFieldStop()
9936 
    oprot.writeStructEnd()
9937 
 
3431 rajveer 9938 
  def validate(self):
9939 
    return
9940 
 
9941 
 
999 varun.gupt 9942 
  def __repr__(self):
9943 
    L = ['%s=%r' % (key, value)
9944 
      for key, value in self.__dict__.iteritems()]
9945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9946 
 
9947 
  def __eq__(self, other):
9948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9949 
 
9950 
  def __ne__(self, other):
9951 
    return not (self == other)
9952 
 
3427 chandransh 9953 
class getOrdersByShippingDate_args:
9954 
  """
9955 
  Attributes:
9956 
   - fromShippingDate
9957 
   - toShippingDate
9958 
   - providerId
9959 
   - warehouseId
3451 chandransh 9960 
   - cod
3427 chandransh 9961 
  """
9962 
 
9963 
  thrift_spec = (
9964 
    None, # 0
9965 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9966 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9967 
    (3, TType.I64, 'providerId', None, None, ), # 3
9968 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9969 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9970 
  )
9971 
 
3451 chandransh 9972 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9973 
    self.fromShippingDate = fromShippingDate
9974 
    self.toShippingDate = toShippingDate
9975 
    self.providerId = providerId
9976 
    self.warehouseId = warehouseId
3451 chandransh 9977 
    self.cod = cod
3427 chandransh 9978 
 
9979 
  def read(self, iprot):
9980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9982 
      return
9983 
    iprot.readStructBegin()
9984 
    while True:
9985 
      (fname, ftype, fid) = iprot.readFieldBegin()
9986 
      if ftype == TType.STOP:
9987 
        break
9988 
      if fid == 1:
9989 
        if ftype == TType.I64:
9990 
          self.fromShippingDate = iprot.readI64();
9991 
        else:
9992 
          iprot.skip(ftype)
9993 
      elif fid == 2:
9994 
        if ftype == TType.I64:
9995 
          self.toShippingDate = iprot.readI64();
9996 
        else:
9997 
          iprot.skip(ftype)
9998 
      elif fid == 3:
9999 
        if ftype == TType.I64:
10000 
          self.providerId = iprot.readI64();
10001 
        else:
10002 
          iprot.skip(ftype)
10003 
      elif fid == 4:
10004 
        if ftype == TType.I64:
10005 
          self.warehouseId = iprot.readI64();
10006 
        else:
10007 
          iprot.skip(ftype)
3451 chandransh 10008 
      elif fid == 5:
10009 
        if ftype == TType.BOOL:
10010 
          self.cod = iprot.readBool();
10011 
        else:
10012 
          iprot.skip(ftype)
3427 chandransh 10013 
      else:
10014 
        iprot.skip(ftype)
10015 
      iprot.readFieldEnd()
10016 
    iprot.readStructEnd()
10017 
 
10018 
  def write(self, oprot):
10019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10021 
      return
10022 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10023 
    if self.fromShippingDate is not None:
3427 chandransh 10024 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10025 
      oprot.writeI64(self.fromShippingDate)
10026 
      oprot.writeFieldEnd()
3431 rajveer 10027 
    if self.toShippingDate is not None:
3427 chandransh 10028 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10029 
      oprot.writeI64(self.toShippingDate)
10030 
      oprot.writeFieldEnd()
3431 rajveer 10031 
    if self.providerId is not None:
3427 chandransh 10032 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10033 
      oprot.writeI64(self.providerId)
10034 
      oprot.writeFieldEnd()
3431 rajveer 10035 
    if self.warehouseId is not None:
3427 chandransh 10036 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10037 
      oprot.writeI64(self.warehouseId)
10038 
      oprot.writeFieldEnd()
3451 chandransh 10039 
    if self.cod is not None:
10040 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10041 
      oprot.writeBool(self.cod)
10042 
      oprot.writeFieldEnd()
3427 chandransh 10043 
    oprot.writeFieldStop()
10044 
    oprot.writeStructEnd()
10045 
 
3431 rajveer 10046 
  def validate(self):
10047 
    return
10048 
 
10049 
 
3427 chandransh 10050 
  def __repr__(self):
10051 
    L = ['%s=%r' % (key, value)
10052 
      for key, value in self.__dict__.iteritems()]
10053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10054 
 
10055 
  def __eq__(self, other):
10056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10057 
 
10058 
  def __ne__(self, other):
10059 
    return not (self == other)
10060 
 
10061 
class getOrdersByShippingDate_result:
10062 
  """
10063 
  Attributes:
10064 
   - success
10065 
   - ex
10066 
  """
10067 
 
10068 
  thrift_spec = (
10069 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10070 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10071 
  )
10072 
 
10073 
  def __init__(self, success=None, ex=None,):
10074 
    self.success = success
10075 
    self.ex = ex
10076 
 
10077 
  def read(self, iprot):
10078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10080 
      return
10081 
    iprot.readStructBegin()
10082 
    while True:
10083 
      (fname, ftype, fid) = iprot.readFieldBegin()
10084 
      if ftype == TType.STOP:
10085 
        break
10086 
      if fid == 0:
10087 
        if ftype == TType.LIST:
10088 
          self.success = []
6031 rajveer 10089 
          (_etype122, _size119) = iprot.readListBegin()
10090 
          for _i123 in xrange(_size119):
10091 
            _elem124 = Order()
10092 
            _elem124.read(iprot)
10093 
            self.success.append(_elem124)
3427 chandransh 10094 
          iprot.readListEnd()
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      elif fid == 1:
10098 
        if ftype == TType.STRUCT:
10099 
          self.ex = TransactionServiceException()
10100 
          self.ex.read(iprot)
10101 
        else:
10102 
          iprot.skip(ftype)
10103 
      else:
10104 
        iprot.skip(ftype)
10105 
      iprot.readFieldEnd()
10106 
    iprot.readStructEnd()
10107 
 
10108 
  def write(self, oprot):
10109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10111 
      return
10112 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10113 
    if self.success is not None:
3427 chandransh 10114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10115 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10116 
      for iter125 in self.success:
10117 
        iter125.write(oprot)
3427 chandransh 10118 
      oprot.writeListEnd()
10119 
      oprot.writeFieldEnd()
3431 rajveer 10120 
    if self.ex is not None:
3427 chandransh 10121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10122 
      self.ex.write(oprot)
10123 
      oprot.writeFieldEnd()
10124 
    oprot.writeFieldStop()
10125 
    oprot.writeStructEnd()
10126 
 
3431 rajveer 10127 
  def validate(self):
10128 
    return
10129 
 
10130 
 
3427 chandransh 10131 
  def __repr__(self):
10132 
    L = ['%s=%r' % (key, value)
10133 
      for key, value in self.__dict__.iteritems()]
10134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10135 
 
10136 
  def __eq__(self, other):
10137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10138 
 
10139 
  def __ne__(self, other):
10140 
    return not (self == other)
10141 
 
1382 varun.gupt 10142 
class getReturnableOrdersForCustomer_args:
10143 
  """
10144 
  Attributes:
10145 
   - customer_id
10146 
   - limit
10147 
  """
10148 
 
10149 
  thrift_spec = (
10150 
    None, # 0
10151 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10152 
    (2, TType.I64, 'limit', None, None, ), # 2
10153 
  )
10154 
 
10155 
  def __init__(self, customer_id=None, limit=None,):
10156 
    self.customer_id = customer_id
10157 
    self.limit = limit
10158 
 
10159 
  def read(self, iprot):
10160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10162 
      return
10163 
    iprot.readStructBegin()
10164 
    while True:
10165 
      (fname, ftype, fid) = iprot.readFieldBegin()
10166 
      if ftype == TType.STOP:
10167 
        break
10168 
      if fid == 1:
10169 
        if ftype == TType.I64:
10170 
          self.customer_id = iprot.readI64();
10171 
        else:
10172 
          iprot.skip(ftype)
10173 
      elif fid == 2:
10174 
        if ftype == TType.I64:
10175 
          self.limit = iprot.readI64();
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
10187 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10188 
    if self.customer_id is not None:
1382 varun.gupt 10189 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10190 
      oprot.writeI64(self.customer_id)
10191 
      oprot.writeFieldEnd()
3431 rajveer 10192 
    if self.limit is not None:
1382 varun.gupt 10193 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10194 
      oprot.writeI64(self.limit)
10195 
      oprot.writeFieldEnd()
10196 
    oprot.writeFieldStop()
10197 
    oprot.writeStructEnd()
10198 
 
3431 rajveer 10199 
  def validate(self):
10200 
    return
10201 
 
10202 
 
1382 varun.gupt 10203 
  def __repr__(self):
10204 
    L = ['%s=%r' % (key, value)
10205 
      for key, value in self.__dict__.iteritems()]
10206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10207 
 
10208 
  def __eq__(self, other):
10209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10210 
 
10211 
  def __ne__(self, other):
10212 
    return not (self == other)
10213 
 
10214 
class getReturnableOrdersForCustomer_result:
10215 
  """
10216 
  Attributes:
10217 
   - success
10218 
   - ex
10219 
  """
10220 
 
10221 
  thrift_spec = (
10222 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10224 
  )
10225 
 
10226 
  def __init__(self, success=None, ex=None,):
10227 
    self.success = success
10228 
    self.ex = ex
10229 
 
10230 
  def read(self, iprot):
10231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10233 
      return
10234 
    iprot.readStructBegin()
10235 
    while True:
10236 
      (fname, ftype, fid) = iprot.readFieldBegin()
10237 
      if ftype == TType.STOP:
10238 
        break
10239 
      if fid == 0:
10240 
        if ftype == TType.LIST:
10241 
          self.success = []
6031 rajveer 10242 
          (_etype129, _size126) = iprot.readListBegin()
10243 
          for _i130 in xrange(_size126):
10244 
            _elem131 = iprot.readI64();
10245 
            self.success.append(_elem131)
1382 varun.gupt 10246 
          iprot.readListEnd()
10247 
        else:
10248 
          iprot.skip(ftype)
10249 
      elif fid == 1:
10250 
        if ftype == TType.STRUCT:
10251 
          self.ex = TransactionServiceException()
10252 
          self.ex.read(iprot)
10253 
        else:
10254 
          iprot.skip(ftype)
10255 
      else:
10256 
        iprot.skip(ftype)
10257 
      iprot.readFieldEnd()
10258 
    iprot.readStructEnd()
10259 
 
10260 
  def write(self, oprot):
10261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10263 
      return
10264 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10265 
    if self.success is not None:
1382 varun.gupt 10266 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10267 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10268 
      for iter132 in self.success:
10269 
        oprot.writeI64(iter132)
1382 varun.gupt 10270 
      oprot.writeListEnd()
10271 
      oprot.writeFieldEnd()
3431 rajveer 10272 
    if self.ex is not None:
1382 varun.gupt 10273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10274 
      self.ex.write(oprot)
10275 
      oprot.writeFieldEnd()
10276 
    oprot.writeFieldStop()
10277 
    oprot.writeStructEnd()
10278 
 
3431 rajveer 10279 
  def validate(self):
10280 
    return
10281 
 
10282 
 
1382 varun.gupt 10283 
  def __repr__(self):
10284 
    L = ['%s=%r' % (key, value)
10285 
      for key, value in self.__dict__.iteritems()]
10286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10287 
 
10288 
  def __eq__(self, other):
10289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10290 
 
10291 
  def __ne__(self, other):
10292 
    return not (self == other)
10293 
 
10294 
class getCancellableOrdersForCustomer_args:
10295 
  """
10296 
  Attributes:
10297 
   - customer_id
10298 
   - limit
10299 
  """
10300 
 
10301 
  thrift_spec = (
10302 
    None, # 0
10303 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10304 
    (2, TType.I64, 'limit', None, None, ), # 2
10305 
  )
10306 
 
10307 
  def __init__(self, customer_id=None, limit=None,):
10308 
    self.customer_id = customer_id
10309 
    self.limit = limit
10310 
 
10311 
  def read(self, iprot):
10312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10314 
      return
10315 
    iprot.readStructBegin()
10316 
    while True:
10317 
      (fname, ftype, fid) = iprot.readFieldBegin()
10318 
      if ftype == TType.STOP:
10319 
        break
10320 
      if fid == 1:
10321 
        if ftype == TType.I64:
10322 
          self.customer_id = iprot.readI64();
10323 
        else:
10324 
          iprot.skip(ftype)
10325 
      elif fid == 2:
10326 
        if ftype == TType.I64:
10327 
          self.limit = iprot.readI64();
10328 
        else:
10329 
          iprot.skip(ftype)
10330 
      else:
10331 
        iprot.skip(ftype)
10332 
      iprot.readFieldEnd()
10333 
    iprot.readStructEnd()
10334 
 
10335 
  def write(self, oprot):
10336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10338 
      return
10339 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10340 
    if self.customer_id is not None:
1382 varun.gupt 10341 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10342 
      oprot.writeI64(self.customer_id)
10343 
      oprot.writeFieldEnd()
3431 rajveer 10344 
    if self.limit is not None:
1382 varun.gupt 10345 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10346 
      oprot.writeI64(self.limit)
10347 
      oprot.writeFieldEnd()
10348 
    oprot.writeFieldStop()
10349 
    oprot.writeStructEnd()
10350 
 
3431 rajveer 10351 
  def validate(self):
10352 
    return
10353 
 
10354 
 
1382 varun.gupt 10355 
  def __repr__(self):
10356 
    L = ['%s=%r' % (key, value)
10357 
      for key, value in self.__dict__.iteritems()]
10358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10359 
 
10360 
  def __eq__(self, other):
10361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10362 
 
10363 
  def __ne__(self, other):
10364 
    return not (self == other)
10365 
 
10366 
class getCancellableOrdersForCustomer_result:
10367 
  """
10368 
  Attributes:
10369 
   - success
10370 
   - ex
10371 
  """
10372 
 
10373 
  thrift_spec = (
10374 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10376 
  )
10377 
 
10378 
  def __init__(self, success=None, ex=None,):
10379 
    self.success = success
10380 
    self.ex = ex
10381 
 
10382 
  def read(self, iprot):
10383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10385 
      return
10386 
    iprot.readStructBegin()
10387 
    while True:
10388 
      (fname, ftype, fid) = iprot.readFieldBegin()
10389 
      if ftype == TType.STOP:
10390 
        break
10391 
      if fid == 0:
10392 
        if ftype == TType.LIST:
10393 
          self.success = []
6031 rajveer 10394 
          (_etype136, _size133) = iprot.readListBegin()
10395 
          for _i137 in xrange(_size133):
10396 
            _elem138 = iprot.readI64();
10397 
            self.success.append(_elem138)
1382 varun.gupt 10398 
          iprot.readListEnd()
10399 
        else:
10400 
          iprot.skip(ftype)
10401 
      elif fid == 1:
10402 
        if ftype == TType.STRUCT:
10403 
          self.ex = TransactionServiceException()
10404 
          self.ex.read(iprot)
10405 
        else:
10406 
          iprot.skip(ftype)
10407 
      else:
10408 
        iprot.skip(ftype)
10409 
      iprot.readFieldEnd()
10410 
    iprot.readStructEnd()
10411 
 
10412 
  def write(self, oprot):
10413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10415 
      return
10416 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10417 
    if self.success is not None:
1382 varun.gupt 10418 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10419 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10420 
      for iter139 in self.success:
10421 
        oprot.writeI64(iter139)
1382 varun.gupt 10422 
      oprot.writeListEnd()
10423 
      oprot.writeFieldEnd()
3431 rajveer 10424 
    if self.ex is not None:
1382 varun.gupt 10425 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10426 
      self.ex.write(oprot)
10427 
      oprot.writeFieldEnd()
10428 
    oprot.writeFieldStop()
10429 
    oprot.writeStructEnd()
10430 
 
3431 rajveer 10431 
  def validate(self):
10432 
    return
10433 
 
10434 
 
1382 varun.gupt 10435 
  def __repr__(self):
10436 
    L = ['%s=%r' % (key, value)
10437 
      for key, value in self.__dict__.iteritems()]
10438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10439 
 
10440 
  def __eq__(self, other):
10441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10442 
 
10443 
  def __ne__(self, other):
10444 
    return not (self == other)
10445 
 
483 rajveer 10446 
class changeOrderStatus_args:
94 ashish 10447 
  """
10448 
  Attributes:
483 rajveer 10449 
   - orderId
10450 
   - status
10451 
   - description
94 ashish 10452 
  """
10453 
 
10454 
  thrift_spec = (
10455 
    None, # 0
483 rajveer 10456 
    (1, TType.I64, 'orderId', None, None, ), # 1
10457 
    (2, TType.I32, 'status', None, None, ), # 2
10458 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10459 
  )
10460 
 
483 rajveer 10461 
  def __init__(self, orderId=None, status=None, description=None,):
10462 
    self.orderId = orderId
10463 
    self.status = status
10464 
    self.description = description
94 ashish 10465 
 
10466 
  def read(self, iprot):
10467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10469 
      return
10470 
    iprot.readStructBegin()
10471 
    while True:
10472 
      (fname, ftype, fid) = iprot.readFieldBegin()
10473 
      if ftype == TType.STOP:
10474 
        break
10475 
      if fid == 1:
10476 
        if ftype == TType.I64:
483 rajveer 10477 
          self.orderId = iprot.readI64();
94 ashish 10478 
        else:
10479 
          iprot.skip(ftype)
10480 
      elif fid == 2:
483 rajveer 10481 
        if ftype == TType.I32:
10482 
          self.status = iprot.readI32();
94 ashish 10483 
        else:
10484 
          iprot.skip(ftype)
483 rajveer 10485 
      elif fid == 3:
10486 
        if ftype == TType.STRING:
10487 
          self.description = iprot.readString();
10488 
        else:
10489 
          iprot.skip(ftype)
94 ashish 10490 
      else:
10491 
        iprot.skip(ftype)
10492 
      iprot.readFieldEnd()
10493 
    iprot.readStructEnd()
10494 
 
10495 
  def write(self, oprot):
10496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10498 
      return
483 rajveer 10499 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10500 
    if self.orderId is not None:
483 rajveer 10501 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10502 
      oprot.writeI64(self.orderId)
94 ashish 10503 
      oprot.writeFieldEnd()
3431 rajveer 10504 
    if self.status is not None:
483 rajveer 10505 
      oprot.writeFieldBegin('status', TType.I32, 2)
10506 
      oprot.writeI32(self.status)
94 ashish 10507 
      oprot.writeFieldEnd()
3431 rajveer 10508 
    if self.description is not None:
483 rajveer 10509 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10510 
      oprot.writeString(self.description)
10511 
      oprot.writeFieldEnd()
94 ashish 10512 
    oprot.writeFieldStop()
10513 
    oprot.writeStructEnd()
10514 
 
3431 rajveer 10515 
  def validate(self):
10516 
    return
10517 
 
10518 
 
94 ashish 10519 
  def __repr__(self):
10520 
    L = ['%s=%r' % (key, value)
10521 
      for key, value in self.__dict__.iteritems()]
10522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10523 
 
10524 
  def __eq__(self, other):
10525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10526 
 
10527 
  def __ne__(self, other):
10528 
    return not (self == other)
10529 
 
483 rajveer 10530 
class changeOrderStatus_result:
94 ashish 10531 
  """
10532 
  Attributes:
10533 
   - success
10534 
   - ex
10535 
  """
10536 
 
10537 
  thrift_spec = (
10538 
    (0, TType.BOOL, 'success', None, None, ), # 0
10539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10540 
  )
10541 
 
10542 
  def __init__(self, success=None, ex=None,):
10543 
    self.success = success
10544 
    self.ex = ex
10545 
 
10546 
  def read(self, iprot):
10547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10549 
      return
10550 
    iprot.readStructBegin()
10551 
    while True:
10552 
      (fname, ftype, fid) = iprot.readFieldBegin()
10553 
      if ftype == TType.STOP:
10554 
        break
10555 
      if fid == 0:
10556 
        if ftype == TType.BOOL:
10557 
          self.success = iprot.readBool();
10558 
        else:
10559 
          iprot.skip(ftype)
10560 
      elif fid == 1:
10561 
        if ftype == TType.STRUCT:
10562 
          self.ex = TransactionServiceException()
10563 
          self.ex.read(iprot)
10564 
        else:
10565 
          iprot.skip(ftype)
10566 
      else:
10567 
        iprot.skip(ftype)
10568 
      iprot.readFieldEnd()
10569 
    iprot.readStructEnd()
10570 
 
10571 
  def write(self, oprot):
10572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10574 
      return
483 rajveer 10575 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10576 
    if self.success is not None:
94 ashish 10577 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10578 
      oprot.writeBool(self.success)
10579 
      oprot.writeFieldEnd()
3431 rajveer 10580 
    if self.ex is not None:
94 ashish 10581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10582 
      self.ex.write(oprot)
10583 
      oprot.writeFieldEnd()
10584 
    oprot.writeFieldStop()
10585 
    oprot.writeStructEnd()
10586 
 
3431 rajveer 10587 
  def validate(self):
10588 
    return
10589 
 
10590 
 
94 ashish 10591 
  def __repr__(self):
10592 
    L = ['%s=%r' % (key, value)
10593 
      for key, value in self.__dict__.iteritems()]
10594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10595 
 
10596 
  def __eq__(self, other):
10597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10598 
 
10599 
  def __ne__(self, other):
10600 
    return not (self == other)
10601 
 
3064 chandransh 10602 
class getOrdersForTransaction_args:
494 rajveer 10603 
  """
10604 
  Attributes:
3064 chandransh 10605 
   - transactionId
10606 
   - customerId
494 rajveer 10607 
  """
10608 
 
10609 
  thrift_spec = (
10610 
    None, # 0
3064 chandransh 10611 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10612 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10613 
  )
10614 
 
3064 chandransh 10615 
  def __init__(self, transactionId=None, customerId=None,):
10616 
    self.transactionId = transactionId
10617 
    self.customerId = customerId
494 rajveer 10618 
 
10619 
  def read(self, iprot):
10620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10622 
      return
10623 
    iprot.readStructBegin()
10624 
    while True:
10625 
      (fname, ftype, fid) = iprot.readFieldBegin()
10626 
      if ftype == TType.STOP:
10627 
        break
10628 
      if fid == 1:
10629 
        if ftype == TType.I64:
3064 chandransh 10630 
          self.transactionId = iprot.readI64();
494 rajveer 10631 
        else:
10632 
          iprot.skip(ftype)
10633 
      elif fid == 2:
3064 chandransh 10634 
        if ftype == TType.I64:
10635 
          self.customerId = iprot.readI64();
494 rajveer 10636 
        else:
10637 
          iprot.skip(ftype)
10638 
      else:
10639 
        iprot.skip(ftype)
10640 
      iprot.readFieldEnd()
10641 
    iprot.readStructEnd()
10642 
 
10643 
  def write(self, oprot):
10644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10646 
      return
3064 chandransh 10647 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10648 
    if self.transactionId is not None:
3064 chandransh 10649 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10650 
      oprot.writeI64(self.transactionId)
494 rajveer 10651 
      oprot.writeFieldEnd()
3431 rajveer 10652 
    if self.customerId is not None:
3064 chandransh 10653 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10654 
      oprot.writeI64(self.customerId)
494 rajveer 10655 
      oprot.writeFieldEnd()
10656 
    oprot.writeFieldStop()
10657 
    oprot.writeStructEnd()
10658 
 
3431 rajveer 10659 
  def validate(self):
10660 
    return
10661 
 
10662 
 
494 rajveer 10663 
  def __repr__(self):
10664 
    L = ['%s=%r' % (key, value)
10665 
      for key, value in self.__dict__.iteritems()]
10666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10667 
 
10668 
  def __eq__(self, other):
10669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10670 
 
10671 
  def __ne__(self, other):
10672 
    return not (self == other)
10673 
 
3064 chandransh 10674 
class getOrdersForTransaction_result:
494 rajveer 10675 
  """
10676 
  Attributes:
10677 
   - success
10678 
   - ex
10679 
  """
10680 
 
10681 
  thrift_spec = (
3064 chandransh 10682 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10683 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10684 
  )
10685 
 
10686 
  def __init__(self, success=None, ex=None,):
10687 
    self.success = success
10688 
    self.ex = ex
10689 
 
10690 
  def read(self, iprot):
10691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10693 
      return
10694 
    iprot.readStructBegin()
10695 
    while True:
10696 
      (fname, ftype, fid) = iprot.readFieldBegin()
10697 
      if ftype == TType.STOP:
10698 
        break
10699 
      if fid == 0:
3064 chandransh 10700 
        if ftype == TType.LIST:
10701 
          self.success = []
6031 rajveer 10702 
          (_etype143, _size140) = iprot.readListBegin()
10703 
          for _i144 in xrange(_size140):
10704 
            _elem145 = Order()
10705 
            _elem145.read(iprot)
10706 
            self.success.append(_elem145)
3064 chandransh 10707 
          iprot.readListEnd()
494 rajveer 10708 
        else:
10709 
          iprot.skip(ftype)
10710 
      elif fid == 1:
10711 
        if ftype == TType.STRUCT:
10712 
          self.ex = TransactionServiceException()
10713 
          self.ex.read(iprot)
10714 
        else:
10715 
          iprot.skip(ftype)
10716 
      else:
10717 
        iprot.skip(ftype)
10718 
      iprot.readFieldEnd()
10719 
    iprot.readStructEnd()
10720 
 
10721 
  def write(self, oprot):
10722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10724 
      return
3064 chandransh 10725 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10726 
    if self.success is not None:
3064 chandransh 10727 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10728 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10729 
      for iter146 in self.success:
10730 
        iter146.write(oprot)
3064 chandransh 10731 
      oprot.writeListEnd()
494 rajveer 10732 
      oprot.writeFieldEnd()
3431 rajveer 10733 
    if self.ex is not None:
494 rajveer 10734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10735 
      self.ex.write(oprot)
10736 
      oprot.writeFieldEnd()
10737 
    oprot.writeFieldStop()
10738 
    oprot.writeStructEnd()
10739 
 
3431 rajveer 10740 
  def validate(self):
10741 
    return
10742 
 
10743 
 
494 rajveer 10744 
  def __repr__(self):
10745 
    L = ['%s=%r' % (key, value)
10746 
      for key, value in self.__dict__.iteritems()]
10747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10748 
 
10749 
  def __eq__(self, other):
10750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10751 
 
10752 
  def __ne__(self, other):
10753 
    return not (self == other)
10754 
 
3064 chandransh 10755 
class getOrdersForCustomer_args:
1149 chandransh 10756 
  """
10757 
  Attributes:
3064 chandransh 10758 
   - customerId
10759 
   - from_date
10760 
   - to_date
10761 
   - statuses
1149 chandransh 10762 
  """
10763 
 
10764 
  thrift_spec = (
10765 
    None, # 0
3064 chandransh 10766 
    (1, TType.I64, 'customerId', None, None, ), # 1
10767 
    (2, TType.I64, 'from_date', None, None, ), # 2
10768 
    (3, TType.I64, 'to_date', None, None, ), # 3
10769 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10770 
  )
10771 
 
3064 chandransh 10772 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10773 
    self.customerId = customerId
10774 
    self.from_date = from_date
10775 
    self.to_date = to_date
10776 
    self.statuses = statuses
1149 chandransh 10777 
 
10778 
  def read(self, iprot):
10779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10781 
      return
10782 
    iprot.readStructBegin()
10783 
    while True:
10784 
      (fname, ftype, fid) = iprot.readFieldBegin()
10785 
      if ftype == TType.STOP:
10786 
        break
10787 
      if fid == 1:
10788 
        if ftype == TType.I64:
3064 chandransh 10789 
          self.customerId = iprot.readI64();
1149 chandransh 10790 
        else:
10791 
          iprot.skip(ftype)
10792 
      elif fid == 2:
10793 
        if ftype == TType.I64:
3064 chandransh 10794 
          self.from_date = iprot.readI64();
1149 chandransh 10795 
        else:
10796 
          iprot.skip(ftype)
2783 chandransh 10797 
      elif fid == 3:
10798 
        if ftype == TType.I64:
3064 chandransh 10799 
          self.to_date = iprot.readI64();
2783 chandransh 10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      elif fid == 4:
3064 chandransh 10803 
        if ftype == TType.LIST:
10804 
          self.statuses = []
6031 rajveer 10805 
          (_etype150, _size147) = iprot.readListBegin()
10806 
          for _i151 in xrange(_size147):
10807 
            _elem152 = iprot.readI32();
10808 
            self.statuses.append(_elem152)
3064 chandransh 10809 
          iprot.readListEnd()
2783 chandransh 10810 
        else:
10811 
          iprot.skip(ftype)
1149 chandransh 10812 
      else:
10813 
        iprot.skip(ftype)
10814 
      iprot.readFieldEnd()
10815 
    iprot.readStructEnd()
10816 
 
10817 
  def write(self, oprot):
10818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10820 
      return
3064 chandransh 10821 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10822 
    if self.customerId is not None:
3064 chandransh 10823 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10824 
      oprot.writeI64(self.customerId)
1149 chandransh 10825 
      oprot.writeFieldEnd()
3431 rajveer 10826 
    if self.from_date is not None:
3064 chandransh 10827 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10828 
      oprot.writeI64(self.from_date)
1149 chandransh 10829 
      oprot.writeFieldEnd()
3431 rajveer 10830 
    if self.to_date is not None:
3064 chandransh 10831 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10832 
      oprot.writeI64(self.to_date)
2783 chandransh 10833 
      oprot.writeFieldEnd()
3431 rajveer 10834 
    if self.statuses is not None:
3064 chandransh 10835 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10836 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 10837 
      for iter153 in self.statuses:
10838 
        oprot.writeI32(iter153)
3064 chandransh 10839 
      oprot.writeListEnd()
2783 chandransh 10840 
      oprot.writeFieldEnd()
1149 chandransh 10841 
    oprot.writeFieldStop()
10842 
    oprot.writeStructEnd()
10843 
 
3431 rajveer 10844 
  def validate(self):
10845 
    return
10846 
 
10847 
 
1149 chandransh 10848 
  def __repr__(self):
10849 
    L = ['%s=%r' % (key, value)
10850 
      for key, value in self.__dict__.iteritems()]
10851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10852 
 
10853 
  def __eq__(self, other):
10854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10855 
 
10856 
  def __ne__(self, other):
10857 
    return not (self == other)
10858 
 
3064 chandransh 10859 
class getOrdersForCustomer_result:
1149 chandransh 10860 
  """
10861 
  Attributes:
10862 
   - success
10863 
   - ex
10864 
  """
10865 
 
10866 
  thrift_spec = (
3064 chandransh 10867 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10869 
  )
10870 
 
10871 
  def __init__(self, success=None, ex=None,):
10872 
    self.success = success
10873 
    self.ex = ex
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 == 0:
3064 chandransh 10885 
        if ftype == TType.LIST:
10886 
          self.success = []
6031 rajveer 10887 
          (_etype157, _size154) = iprot.readListBegin()
10888 
          for _i158 in xrange(_size154):
10889 
            _elem159 = Order()
10890 
            _elem159.read(iprot)
10891 
            self.success.append(_elem159)
3064 chandransh 10892 
          iprot.readListEnd()
1149 chandransh 10893 
        else:
10894 
          iprot.skip(ftype)
10895 
      elif fid == 1:
10896 
        if ftype == TType.STRUCT:
10897 
          self.ex = TransactionServiceException()
10898 
          self.ex.read(iprot)
10899 
        else:
10900 
          iprot.skip(ftype)
10901 
      else:
10902 
        iprot.skip(ftype)
10903 
      iprot.readFieldEnd()
10904 
    iprot.readStructEnd()
10905 
 
10906 
  def write(self, oprot):
10907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10909 
      return
3064 chandransh 10910 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10911 
    if self.success is not None:
3064 chandransh 10912 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10913 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10914 
      for iter160 in self.success:
10915 
        iter160.write(oprot)
3064 chandransh 10916 
      oprot.writeListEnd()
1149 chandransh 10917 
      oprot.writeFieldEnd()
3431 rajveer 10918 
    if self.ex is not None:
1149 chandransh 10919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10920 
      self.ex.write(oprot)
10921 
      oprot.writeFieldEnd()
10922 
    oprot.writeFieldStop()
10923 
    oprot.writeStructEnd()
10924 
 
3431 rajveer 10925 
  def validate(self):
10926 
    return
10927 
 
10928 
 
1149 chandransh 10929 
  def __repr__(self):
10930 
    L = ['%s=%r' % (key, value)
10931 
      for key, value in self.__dict__.iteritems()]
10932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10933 
 
10934 
  def __eq__(self, other):
10935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10936 
 
10937 
  def __ne__(self, other):
10938 
    return not (self == other)
10939 
 
3064 chandransh 10940 
class createOrder_args:
921 rajveer 10941 
  """
10942 
  Attributes:
3064 chandransh 10943 
   - order
921 rajveer 10944 
  """
10945 
 
10946 
  thrift_spec = (
10947 
    None, # 0
3064 chandransh 10948 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10949 
  )
10950 
 
3064 chandransh 10951 
  def __init__(self, order=None,):
10952 
    self.order = order
921 rajveer 10953 
 
10954 
  def read(self, iprot):
10955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10957 
      return
10958 
    iprot.readStructBegin()
10959 
    while True:
10960 
      (fname, ftype, fid) = iprot.readFieldBegin()
10961 
      if ftype == TType.STOP:
10962 
        break
10963 
      if fid == 1:
3064 chandransh 10964 
        if ftype == TType.STRUCT:
10965 
          self.order = Order()
10966 
          self.order.read(iprot)
921 rajveer 10967 
        else:
10968 
          iprot.skip(ftype)
10969 
      else:
10970 
        iprot.skip(ftype)
10971 
      iprot.readFieldEnd()
10972 
    iprot.readStructEnd()
10973 
 
10974 
  def write(self, oprot):
10975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10977 
      return
3064 chandransh 10978 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10979 
    if self.order is not None:
3064 chandransh 10980 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10981 
      self.order.write(oprot)
921 rajveer 10982 
      oprot.writeFieldEnd()
10983 
    oprot.writeFieldStop()
10984 
    oprot.writeStructEnd()
10985 
 
3431 rajveer 10986 
  def validate(self):
10987 
    return
10988 
 
10989 
 
921 rajveer 10990 
  def __repr__(self):
10991 
    L = ['%s=%r' % (key, value)
10992 
      for key, value in self.__dict__.iteritems()]
10993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10994 
 
10995 
  def __eq__(self, other):
10996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10997 
 
10998 
  def __ne__(self, other):
10999 
    return not (self == other)
11000 
 
3064 chandransh 11001 
class createOrder_result:
921 rajveer 11002 
  """
11003 
  Attributes:
11004 
   - success
11005 
   - ex
11006 
  """
11007 
 
11008 
  thrift_spec = (
3064 chandransh 11009 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11011 
  )
11012 
 
11013 
  def __init__(self, success=None, ex=None,):
11014 
    self.success = success
11015 
    self.ex = ex
11016 
 
11017 
  def read(self, iprot):
11018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11020 
      return
11021 
    iprot.readStructBegin()
11022 
    while True:
11023 
      (fname, ftype, fid) = iprot.readFieldBegin()
11024 
      if ftype == TType.STOP:
11025 
        break
11026 
      if fid == 0:
3064 chandransh 11027 
        if ftype == TType.I64:
11028 
          self.success = iprot.readI64();
921 rajveer 11029 
        else:
11030 
          iprot.skip(ftype)
11031 
      elif fid == 1:
11032 
        if ftype == TType.STRUCT:
11033 
          self.ex = TransactionServiceException()
11034 
          self.ex.read(iprot)
11035 
        else:
11036 
          iprot.skip(ftype)
11037 
      else:
11038 
        iprot.skip(ftype)
11039 
      iprot.readFieldEnd()
11040 
    iprot.readStructEnd()
11041 
 
11042 
  def write(self, oprot):
11043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11045 
      return
3064 chandransh 11046 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11047 
    if self.success is not None:
3064 chandransh 11048 
      oprot.writeFieldBegin('success', TType.I64, 0)
11049 
      oprot.writeI64(self.success)
921 rajveer 11050 
      oprot.writeFieldEnd()
3431 rajveer 11051 
    if self.ex is not None:
921 rajveer 11052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11053 
      self.ex.write(oprot)
11054 
      oprot.writeFieldEnd()
11055 
    oprot.writeFieldStop()
11056 
    oprot.writeStructEnd()
11057 
 
3431 rajveer 11058 
  def validate(self):
11059 
    return
11060 
 
11061 
 
921 rajveer 11062 
  def __repr__(self):
11063 
    L = ['%s=%r' % (key, value)
11064 
      for key, value in self.__dict__.iteritems()]
11065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11066 
 
11067 
  def __eq__(self, other):
11068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11069 
 
11070 
  def __ne__(self, other):
11071 
    return not (self == other)
11072 
 
3064 chandransh 11073 
class getOrder_args:
921 rajveer 11074 
  """
11075 
  Attributes:
3064 chandransh 11076 
   - id
921 rajveer 11077 
  """
11078 
 
11079 
  thrift_spec = (
11080 
    None, # 0
3064 chandransh 11081 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11082 
  )
11083 
 
3064 chandransh 11084 
  def __init__(self, id=None,):
11085 
    self.id = id
921 rajveer 11086 
 
11087 
  def read(self, iprot):
11088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11090 
      return
11091 
    iprot.readStructBegin()
11092 
    while True:
11093 
      (fname, ftype, fid) = iprot.readFieldBegin()
11094 
      if ftype == TType.STOP:
11095 
        break
11096 
      if fid == 1:
11097 
        if ftype == TType.I64:
3064 chandransh 11098 
          self.id = iprot.readI64();
921 rajveer 11099 
        else:
11100 
          iprot.skip(ftype)
11101 
      else:
11102 
        iprot.skip(ftype)
11103 
      iprot.readFieldEnd()
11104 
    iprot.readStructEnd()
11105 
 
11106 
  def write(self, oprot):
11107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11109 
      return
3064 chandransh 11110 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11111 
    if self.id is not None:
3064 chandransh 11112 
      oprot.writeFieldBegin('id', TType.I64, 1)
11113 
      oprot.writeI64(self.id)
921 rajveer 11114 
      oprot.writeFieldEnd()
11115 
    oprot.writeFieldStop()
11116 
    oprot.writeStructEnd()
11117 
 
3431 rajveer 11118 
  def validate(self):
11119 
    return
11120 
 
11121 
 
921 rajveer 11122 
  def __repr__(self):
11123 
    L = ['%s=%r' % (key, value)
11124 
      for key, value in self.__dict__.iteritems()]
11125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11126 
 
11127 
  def __eq__(self, other):
11128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11129 
 
11130 
  def __ne__(self, other):
11131 
    return not (self == other)
11132 
 
3064 chandransh 11133 
class getOrder_result:
921 rajveer 11134 
  """
11135 
  Attributes:
11136 
   - success
11137 
   - ex
11138 
  """
11139 
 
11140 
  thrift_spec = (
3064 chandransh 11141 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11143 
  )
11144 
 
11145 
  def __init__(self, success=None, ex=None,):
11146 
    self.success = success
11147 
    self.ex = ex
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 == 0:
3064 chandransh 11159 
        if ftype == TType.STRUCT:
11160 
          self.success = Order()
11161 
          self.success.read(iprot)
921 rajveer 11162 
        else:
11163 
          iprot.skip(ftype)
11164 
      elif fid == 1:
11165 
        if ftype == TType.STRUCT:
11166 
          self.ex = TransactionServiceException()
11167 
          self.ex.read(iprot)
11168 
        else:
11169 
          iprot.skip(ftype)
11170 
      else:
11171 
        iprot.skip(ftype)
11172 
      iprot.readFieldEnd()
11173 
    iprot.readStructEnd()
11174 
 
11175 
  def write(self, oprot):
11176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11178 
      return
3064 chandransh 11179 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11180 
    if self.success is not None:
3064 chandransh 11181 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11182 
      self.success.write(oprot)
921 rajveer 11183 
      oprot.writeFieldEnd()
3431 rajveer 11184 
    if self.ex is not None:
921 rajveer 11185 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11186 
      self.ex.write(oprot)
11187 
      oprot.writeFieldEnd()
11188 
    oprot.writeFieldStop()
11189 
    oprot.writeStructEnd()
11190 
 
3431 rajveer 11191 
  def validate(self):
11192 
    return
11193 
 
11194 
 
921 rajveer 11195 
  def __repr__(self):
11196 
    L = ['%s=%r' % (key, value)
11197 
      for key, value in self.__dict__.iteritems()]
11198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11199 
 
11200 
  def __eq__(self, other):
11201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11202 
 
11203 
  def __ne__(self, other):
11204 
    return not (self == other)
11205 
 
3064 chandransh 11206 
class getLineItemsForOrder_args:
94 ashish 11207 
  """
11208 
  Attributes:
3064 chandransh 11209 
   - orderId
94 ashish 11210 
  """
11211 
 
11212 
  thrift_spec = (
11213 
    None, # 0
3064 chandransh 11214 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11215 
  )
11216 
 
3064 chandransh 11217 
  def __init__(self, orderId=None,):
11218 
    self.orderId = orderId
94 ashish 11219 
 
11220 
  def read(self, iprot):
11221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11223 
      return
11224 
    iprot.readStructBegin()
11225 
    while True:
11226 
      (fname, ftype, fid) = iprot.readFieldBegin()
11227 
      if ftype == TType.STOP:
11228 
        break
11229 
      if fid == 1:
11230 
        if ftype == TType.I64:
3064 chandransh 11231 
          self.orderId = iprot.readI64();
94 ashish 11232 
        else:
11233 
          iprot.skip(ftype)
11234 
      else:
11235 
        iprot.skip(ftype)
11236 
      iprot.readFieldEnd()
11237 
    iprot.readStructEnd()
11238 
 
11239 
  def write(self, oprot):
11240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11242 
      return
3064 chandransh 11243 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11244 
    if self.orderId is not None:
3064 chandransh 11245 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11246 
      oprot.writeI64(self.orderId)
94 ashish 11247 
      oprot.writeFieldEnd()
11248 
    oprot.writeFieldStop()
11249 
    oprot.writeStructEnd()
11250 
 
3431 rajveer 11251 
  def validate(self):
11252 
    return
11253 
 
11254 
 
94 ashish 11255 
  def __repr__(self):
11256 
    L = ['%s=%r' % (key, value)
11257 
      for key, value in self.__dict__.iteritems()]
11258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11259 
 
11260 
  def __eq__(self, other):
11261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11262 
 
11263 
  def __ne__(self, other):
11264 
    return not (self == other)
11265 
 
3064 chandransh 11266 
class getLineItemsForOrder_result:
94 ashish 11267 
  """
11268 
  Attributes:
11269 
   - success
11270 
   - ex
11271 
  """
11272 
 
11273 
  thrift_spec = (
3064 chandransh 11274 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11276 
  )
11277 
 
11278 
  def __init__(self, success=None, ex=None,):
11279 
    self.success = success
11280 
    self.ex = ex
11281 
 
11282 
  def read(self, iprot):
11283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11285 
      return
11286 
    iprot.readStructBegin()
11287 
    while True:
11288 
      (fname, ftype, fid) = iprot.readFieldBegin()
11289 
      if ftype == TType.STOP:
11290 
        break
11291 
      if fid == 0:
483 rajveer 11292 
        if ftype == TType.LIST:
11293 
          self.success = []
6031 rajveer 11294 
          (_etype164, _size161) = iprot.readListBegin()
11295 
          for _i165 in xrange(_size161):
11296 
            _elem166 = LineItem()
11297 
            _elem166.read(iprot)
11298 
            self.success.append(_elem166)
483 rajveer 11299 
          iprot.readListEnd()
94 ashish 11300 
        else:
11301 
          iprot.skip(ftype)
11302 
      elif fid == 1:
11303 
        if ftype == TType.STRUCT:
11304 
          self.ex = TransactionServiceException()
11305 
          self.ex.read(iprot)
11306 
        else:
11307 
          iprot.skip(ftype)
11308 
      else:
11309 
        iprot.skip(ftype)
11310 
      iprot.readFieldEnd()
11311 
    iprot.readStructEnd()
11312 
 
11313 
  def write(self, oprot):
11314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11316 
      return
3064 chandransh 11317 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11318 
    if self.success is not None:
483 rajveer 11319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11321 
      for iter167 in self.success:
11322 
        iter167.write(oprot)
483 rajveer 11323 
      oprot.writeListEnd()
94 ashish 11324 
      oprot.writeFieldEnd()
3431 rajveer 11325 
    if self.ex is not None:
94 ashish 11326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11327 
      self.ex.write(oprot)
11328 
      oprot.writeFieldEnd()
11329 
    oprot.writeFieldStop()
11330 
    oprot.writeStructEnd()
11331 
 
3431 rajveer 11332 
  def validate(self):
11333 
    return
11334 
 
11335 
 
94 ashish 11336 
  def __repr__(self):
11337 
    L = ['%s=%r' % (key, value)
11338 
      for key, value in self.__dict__.iteritems()]
11339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11340 
 
11341 
  def __eq__(self, other):
11342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11343 
 
11344 
  def __ne__(self, other):
11345 
    return not (self == other)
11346 
 
4999 phani.kuma 11347 
class getOrderList_args:
11348 
  """
11349 
  Attributes:
11350 
   - order_ids
11351 
  """
11352 
 
11353 
  thrift_spec = (
11354 
    None, # 0
11355 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11356 
  )
11357 
 
11358 
  def __init__(self, order_ids=None,):
11359 
    self.order_ids = order_ids
11360 
 
11361 
  def read(self, iprot):
11362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11364 
      return
11365 
    iprot.readStructBegin()
11366 
    while True:
11367 
      (fname, ftype, fid) = iprot.readFieldBegin()
11368 
      if ftype == TType.STOP:
11369 
        break
11370 
      if fid == 1:
11371 
        if ftype == TType.LIST:
11372 
          self.order_ids = []
6031 rajveer 11373 
          (_etype171, _size168) = iprot.readListBegin()
11374 
          for _i172 in xrange(_size168):
11375 
            _elem173 = iprot.readI64();
11376 
            self.order_ids.append(_elem173)
4999 phani.kuma 11377 
          iprot.readListEnd()
11378 
        else:
11379 
          iprot.skip(ftype)
11380 
      else:
11381 
        iprot.skip(ftype)
11382 
      iprot.readFieldEnd()
11383 
    iprot.readStructEnd()
11384 
 
11385 
  def write(self, oprot):
11386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11388 
      return
11389 
    oprot.writeStructBegin('getOrderList_args')
11390 
    if self.order_ids is not None:
11391 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11392 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11393 
      for iter174 in self.order_ids:
11394 
        oprot.writeI64(iter174)
4999 phani.kuma 11395 
      oprot.writeListEnd()
11396 
      oprot.writeFieldEnd()
11397 
    oprot.writeFieldStop()
11398 
    oprot.writeStructEnd()
11399 
 
11400 
  def validate(self):
11401 
    return
11402 
 
11403 
 
11404 
  def __repr__(self):
11405 
    L = ['%s=%r' % (key, value)
11406 
      for key, value in self.__dict__.iteritems()]
11407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11408 
 
11409 
  def __eq__(self, other):
11410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11411 
 
11412 
  def __ne__(self, other):
11413 
    return not (self == other)
11414 
 
11415 
class getOrderList_result:
11416 
  """
11417 
  Attributes:
11418 
   - success
11419 
  """
11420 
 
11421 
  thrift_spec = (
11422 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11423 
  )
11424 
 
11425 
  def __init__(self, success=None,):
11426 
    self.success = success
11427 
 
11428 
  def read(self, iprot):
11429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11431 
      return
11432 
    iprot.readStructBegin()
11433 
    while True:
11434 
      (fname, ftype, fid) = iprot.readFieldBegin()
11435 
      if ftype == TType.STOP:
11436 
        break
11437 
      if fid == 0:
11438 
        if ftype == TType.LIST:
11439 
          self.success = []
6031 rajveer 11440 
          (_etype178, _size175) = iprot.readListBegin()
11441 
          for _i179 in xrange(_size175):
11442 
            _elem180 = Order()
11443 
            _elem180.read(iprot)
11444 
            self.success.append(_elem180)
4999 phani.kuma 11445 
          iprot.readListEnd()
11446 
        else:
11447 
          iprot.skip(ftype)
11448 
      else:
11449 
        iprot.skip(ftype)
11450 
      iprot.readFieldEnd()
11451 
    iprot.readStructEnd()
11452 
 
11453 
  def write(self, oprot):
11454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11456 
      return
11457 
    oprot.writeStructBegin('getOrderList_result')
11458 
    if self.success is not None:
11459 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11460 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11461 
      for iter181 in self.success:
11462 
        iter181.write(oprot)
4999 phani.kuma 11463 
      oprot.writeListEnd()
11464 
      oprot.writeFieldEnd()
11465 
    oprot.writeFieldStop()
11466 
    oprot.writeStructEnd()
11467 
 
11468 
  def validate(self):
11469 
    return
11470 
 
11471 
 
11472 
  def __repr__(self):
11473 
    L = ['%s=%r' % (key, value)
11474 
      for key, value in self.__dict__.iteritems()]
11475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11476 
 
11477 
  def __eq__(self, other):
11478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11479 
 
11480 
  def __ne__(self, other):
11481 
    return not (self == other)
11482 
 
5386 phani.kuma 11483 
class getOrderListForVendor_args:
11484 
  """
11485 
  Attributes:
11486 
   - order_ids
11487 
   - vendorId
11488 
  """
11489 
 
11490 
  thrift_spec = (
11491 
    None, # 0
11492 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11493 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11494 
  )
11495 
 
11496 
  def __init__(self, order_ids=None, vendorId=None,):
11497 
    self.order_ids = order_ids
11498 
    self.vendorId = vendorId
11499 
 
11500 
  def read(self, iprot):
11501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11503 
      return
11504 
    iprot.readStructBegin()
11505 
    while True:
11506 
      (fname, ftype, fid) = iprot.readFieldBegin()
11507 
      if ftype == TType.STOP:
11508 
        break
11509 
      if fid == 1:
11510 
        if ftype == TType.LIST:
11511 
          self.order_ids = []
6031 rajveer 11512 
          (_etype185, _size182) = iprot.readListBegin()
11513 
          for _i186 in xrange(_size182):
11514 
            _elem187 = iprot.readI64();
11515 
            self.order_ids.append(_elem187)
5386 phani.kuma 11516 
          iprot.readListEnd()
11517 
        else:
11518 
          iprot.skip(ftype)
11519 
      elif fid == 2:
11520 
        if ftype == TType.I64:
11521 
          self.vendorId = iprot.readI64();
11522 
        else:
11523 
          iprot.skip(ftype)
11524 
      else:
11525 
        iprot.skip(ftype)
11526 
      iprot.readFieldEnd()
11527 
    iprot.readStructEnd()
11528 
 
11529 
  def write(self, oprot):
11530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11532 
      return
11533 
    oprot.writeStructBegin('getOrderListForVendor_args')
11534 
    if self.order_ids is not None:
11535 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11536 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11537 
      for iter188 in self.order_ids:
11538 
        oprot.writeI64(iter188)
5386 phani.kuma 11539 
      oprot.writeListEnd()
11540 
      oprot.writeFieldEnd()
11541 
    if self.vendorId is not None:
11542 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11543 
      oprot.writeI64(self.vendorId)
11544 
      oprot.writeFieldEnd()
11545 
    oprot.writeFieldStop()
11546 
    oprot.writeStructEnd()
11547 
 
11548 
  def validate(self):
11549 
    return
11550 
 
11551 
 
11552 
  def __repr__(self):
11553 
    L = ['%s=%r' % (key, value)
11554 
      for key, value in self.__dict__.iteritems()]
11555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11556 
 
11557 
  def __eq__(self, other):
11558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11559 
 
11560 
  def __ne__(self, other):
11561 
    return not (self == other)
11562 
 
11563 
class getOrderListForVendor_result:
11564 
  """
11565 
  Attributes:
11566 
   - success
11567 
  """
11568 
 
11569 
  thrift_spec = (
11570 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11571 
  )
11572 
 
11573 
  def __init__(self, success=None,):
11574 
    self.success = success
11575 
 
11576 
  def read(self, iprot):
11577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11579 
      return
11580 
    iprot.readStructBegin()
11581 
    while True:
11582 
      (fname, ftype, fid) = iprot.readFieldBegin()
11583 
      if ftype == TType.STOP:
11584 
        break
11585 
      if fid == 0:
11586 
        if ftype == TType.LIST:
11587 
          self.success = []
6031 rajveer 11588 
          (_etype192, _size189) = iprot.readListBegin()
11589 
          for _i193 in xrange(_size189):
11590 
            _elem194 = Order()
11591 
            _elem194.read(iprot)
11592 
            self.success.append(_elem194)
5386 phani.kuma 11593 
          iprot.readListEnd()
11594 
        else:
11595 
          iprot.skip(ftype)
11596 
      else:
11597 
        iprot.skip(ftype)
11598 
      iprot.readFieldEnd()
11599 
    iprot.readStructEnd()
11600 
 
11601 
  def write(self, oprot):
11602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11604 
      return
11605 
    oprot.writeStructBegin('getOrderListForVendor_result')
11606 
    if self.success is not None:
11607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11609 
      for iter195 in self.success:
11610 
        iter195.write(oprot)
5386 phani.kuma 11611 
      oprot.writeListEnd()
11612 
      oprot.writeFieldEnd()
11613 
    oprot.writeFieldStop()
11614 
    oprot.writeStructEnd()
11615 
 
11616 
  def validate(self):
11617 
    return
11618 
 
11619 
 
11620 
  def __repr__(self):
11621 
    L = ['%s=%r' % (key, value)
11622 
      for key, value in self.__dict__.iteritems()]
11623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11624 
 
11625 
  def __eq__(self, other):
11626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11627 
 
11628 
  def __ne__(self, other):
11629 
    return not (self == other)
11630 
 
3064 chandransh 11631 
class getOrderForCustomer_args:
94 ashish 11632 
  """
11633 
  Attributes:
3064 chandransh 11634 
   - orderId
483 rajveer 11635 
   - customerId
94 ashish 11636 
  """
11637 
 
11638 
  thrift_spec = (
11639 
    None, # 0
3064 chandransh 11640 
    (1, TType.I64, 'orderId', None, None, ), # 1
11641 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11642 
  )
11643 
 
3064 chandransh 11644 
  def __init__(self, orderId=None, customerId=None,):
11645 
    self.orderId = orderId
483 rajveer 11646 
    self.customerId = customerId
94 ashish 11647 
 
11648 
  def read(self, iprot):
11649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11651 
      return
11652 
    iprot.readStructBegin()
11653 
    while True:
11654 
      (fname, ftype, fid) = iprot.readFieldBegin()
11655 
      if ftype == TType.STOP:
11656 
        break
11657 
      if fid == 1:
11658 
        if ftype == TType.I64:
3064 chandransh 11659 
          self.orderId = iprot.readI64();
94 ashish 11660 
        else:
11661 
          iprot.skip(ftype)
11662 
      elif fid == 2:
11663 
        if ftype == TType.I64:
3064 chandransh 11664 
          self.customerId = iprot.readI64();
94 ashish 11665 
        else:
11666 
          iprot.skip(ftype)
11667 
      else:
11668 
        iprot.skip(ftype)
11669 
      iprot.readFieldEnd()
11670 
    iprot.readStructEnd()
11671 
 
11672 
  def write(self, oprot):
11673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11675 
      return
3064 chandransh 11676 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11677 
    if self.orderId is not None:
3064 chandransh 11678 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11679 
      oprot.writeI64(self.orderId)
11680 
      oprot.writeFieldEnd()
3431 rajveer 11681 
    if self.customerId is not None:
3064 chandransh 11682 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11683 
      oprot.writeI64(self.customerId)
94 ashish 11684 
      oprot.writeFieldEnd()
11685 
    oprot.writeFieldStop()
11686 
    oprot.writeStructEnd()
11687 
 
3431 rajveer 11688 
  def validate(self):
11689 
    return
11690 
 
11691 
 
94 ashish 11692 
  def __repr__(self):
11693 
    L = ['%s=%r' % (key, value)
11694 
      for key, value in self.__dict__.iteritems()]
11695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11696 
 
11697 
  def __eq__(self, other):
11698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11699 
 
11700 
  def __ne__(self, other):
11701 
    return not (self == other)
11702 
 
3064 chandransh 11703 
class getOrderForCustomer_result:
94 ashish 11704 
  """
11705 
  Attributes:
11706 
   - success
11707 
   - ex
11708 
  """
11709 
 
11710 
  thrift_spec = (
3064 chandransh 11711 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11713 
  )
11714 
 
11715 
  def __init__(self, success=None, ex=None,):
11716 
    self.success = success
11717 
    self.ex = ex
11718 
 
11719 
  def read(self, iprot):
11720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11722 
      return
11723 
    iprot.readStructBegin()
11724 
    while True:
11725 
      (fname, ftype, fid) = iprot.readFieldBegin()
11726 
      if ftype == TType.STOP:
11727 
        break
11728 
      if fid == 0:
3064 chandransh 11729 
        if ftype == TType.STRUCT:
11730 
          self.success = Order()
11731 
          self.success.read(iprot)
94 ashish 11732 
        else:
11733 
          iprot.skip(ftype)
11734 
      elif fid == 1:
11735 
        if ftype == TType.STRUCT:
11736 
          self.ex = TransactionServiceException()
11737 
          self.ex.read(iprot)
11738 
        else:
11739 
          iprot.skip(ftype)
11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
3064 chandransh 11749 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11750 
    if self.success is not None:
3064 chandransh 11751 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11752 
      self.success.write(oprot)
94 ashish 11753 
      oprot.writeFieldEnd()
3431 rajveer 11754 
    if self.ex is not None:
94 ashish 11755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11756 
      self.ex.write(oprot)
11757 
      oprot.writeFieldEnd()
11758 
    oprot.writeFieldStop()
11759 
    oprot.writeStructEnd()
11760 
 
3431 rajveer 11761 
  def validate(self):
11762 
    return
11763 
 
11764 
 
94 ashish 11765 
  def __repr__(self):
11766 
    L = ['%s=%r' % (key, value)
11767 
      for key, value in self.__dict__.iteritems()]
11768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11769 
 
11770 
  def __eq__(self, other):
11771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11772 
 
11773 
  def __ne__(self, other):
11774 
    return not (self == other)
11775 
 
3064 chandransh 11776 
class getAlerts_args:
94 ashish 11777 
  """
11778 
  Attributes:
4394 rajveer 11779 
   - type
4444 rajveer 11780 
   - warehouseId
4394 rajveer 11781 
   - status
11782 
   - timestamp
94 ashish 11783 
  """
11784 
 
11785 
  thrift_spec = (
11786 
    None, # 0
4394 rajveer 11787 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11788 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11789 
    (3, TType.I64, 'status', None, None, ), # 3
11790 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11791 
  )
11792 
 
4444 rajveer 11793 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11794 
    self.type = type
4444 rajveer 11795 
    self.warehouseId = warehouseId
4394 rajveer 11796 
    self.status = status
11797 
    self.timestamp = timestamp
94 ashish 11798 
 
11799 
  def read(self, iprot):
11800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11802 
      return
11803 
    iprot.readStructBegin()
11804 
    while True:
11805 
      (fname, ftype, fid) = iprot.readFieldBegin()
11806 
      if ftype == TType.STOP:
11807 
        break
11808 
      if fid == 1:
3064 chandransh 11809 
        if ftype == TType.I64:
4394 rajveer 11810 
          self.type = iprot.readI64();
94 ashish 11811 
        else:
11812 
          iprot.skip(ftype)
3064 chandransh 11813 
      elif fid == 2:
4394 rajveer 11814 
        if ftype == TType.I64:
4444 rajveer 11815 
          self.warehouseId = iprot.readI64();
3064 chandransh 11816 
        else:
11817 
          iprot.skip(ftype)
4394 rajveer 11818 
      elif fid == 3:
11819 
        if ftype == TType.I64:
4444 rajveer 11820 
          self.status = iprot.readI64();
11821 
        else:
11822 
          iprot.skip(ftype)
11823 
      elif fid == 4:
11824 
        if ftype == TType.I64:
4394 rajveer 11825 
          self.timestamp = iprot.readI64();
11826 
        else:
11827 
          iprot.skip(ftype)
94 ashish 11828 
      else:
11829 
        iprot.skip(ftype)
11830 
      iprot.readFieldEnd()
11831 
    iprot.readStructEnd()
11832 
 
11833 
  def write(self, oprot):
11834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11836 
      return
3064 chandransh 11837 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11838 
    if self.type is not None:
11839 
      oprot.writeFieldBegin('type', TType.I64, 1)
11840 
      oprot.writeI64(self.type)
94 ashish 11841 
      oprot.writeFieldEnd()
4444 rajveer 11842 
    if self.warehouseId is not None:
11843 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11844 
      oprot.writeI64(self.warehouseId)
11845 
      oprot.writeFieldEnd()
4394 rajveer 11846 
    if self.status is not None:
4444 rajveer 11847 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11848 
      oprot.writeI64(self.status)
3064 chandransh 11849 
      oprot.writeFieldEnd()
4394 rajveer 11850 
    if self.timestamp is not None:
4444 rajveer 11851 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11852 
      oprot.writeI64(self.timestamp)
11853 
      oprot.writeFieldEnd()
94 ashish 11854 
    oprot.writeFieldStop()
11855 
    oprot.writeStructEnd()
11856 
 
3431 rajveer 11857 
  def validate(self):
11858 
    return
11859 
 
11860 
 
94 ashish 11861 
  def __repr__(self):
11862 
    L = ['%s=%r' % (key, value)
11863 
      for key, value in self.__dict__.iteritems()]
11864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11865 
 
11866 
  def __eq__(self, other):
11867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11868 
 
11869 
  def __ne__(self, other):
11870 
    return not (self == other)
11871 
 
3064 chandransh 11872 
class getAlerts_result:
94 ashish 11873 
  """
11874 
  Attributes:
11875 
   - success
11876 
  """
11877 
 
11878 
  thrift_spec = (
3064 chandransh 11879 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11880 
  )
11881 
 
3064 chandransh 11882 
  def __init__(self, success=None,):
94 ashish 11883 
    self.success = success
11884 
 
11885 
  def read(self, iprot):
11886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11888 
      return
11889 
    iprot.readStructBegin()
11890 
    while True:
11891 
      (fname, ftype, fid) = iprot.readFieldBegin()
11892 
      if ftype == TType.STOP:
11893 
        break
11894 
      if fid == 0:
3064 chandransh 11895 
        if ftype == TType.LIST:
11896 
          self.success = []
6031 rajveer 11897 
          (_etype199, _size196) = iprot.readListBegin()
11898 
          for _i200 in xrange(_size196):
11899 
            _elem201 = Alert()
11900 
            _elem201.read(iprot)
11901 
            self.success.append(_elem201)
3064 chandransh 11902 
          iprot.readListEnd()
94 ashish 11903 
        else:
11904 
          iprot.skip(ftype)
11905 
      else:
11906 
        iprot.skip(ftype)
11907 
      iprot.readFieldEnd()
11908 
    iprot.readStructEnd()
11909 
 
11910 
  def write(self, oprot):
11911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11913 
      return
3064 chandransh 11914 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11915 
    if self.success is not None:
3064 chandransh 11916 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11917 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11918 
      for iter202 in self.success:
11919 
        iter202.write(oprot)
3064 chandransh 11920 
      oprot.writeListEnd()
94 ashish 11921 
      oprot.writeFieldEnd()
11922 
    oprot.writeFieldStop()
11923 
    oprot.writeStructEnd()
11924 
 
3431 rajveer 11925 
  def validate(self):
11926 
    return
11927 
 
11928 
 
94 ashish 11929 
  def __repr__(self):
11930 
    L = ['%s=%r' % (key, value)
11931 
      for key, value in self.__dict__.iteritems()]
11932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11933 
 
11934 
  def __eq__(self, other):
11935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11936 
 
11937 
  def __ne__(self, other):
11938 
    return not (self == other)
11939 
 
4394 rajveer 11940 
class addAlert_args:
94 ashish 11941 
  """
11942 
  Attributes:
3064 chandransh 11943 
   - type
4444 rajveer 11944 
   - warehouseId
4394 rajveer 11945 
   - description
94 ashish 11946 
  """
11947 
 
11948 
  thrift_spec = (
11949 
    None, # 0
4394 rajveer 11950 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11951 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11952 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11953 
  )
11954 
 
4444 rajveer 11955 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11956 
    self.type = type
4444 rajveer 11957 
    self.warehouseId = warehouseId
4394 rajveer 11958 
    self.description = description
94 ashish 11959 
 
11960 
  def read(self, iprot):
11961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11963 
      return
11964 
    iprot.readStructBegin()
11965 
    while True:
11966 
      (fname, ftype, fid) = iprot.readFieldBegin()
11967 
      if ftype == TType.STOP:
11968 
        break
11969 
      if fid == 1:
11970 
        if ftype == TType.I64:
4394 rajveer 11971 
          self.type = iprot.readI64();
94 ashish 11972 
        else:
11973 
          iprot.skip(ftype)
3064 chandransh 11974 
      elif fid == 2:
4444 rajveer 11975 
        if ftype == TType.I64:
11976 
          self.warehouseId = iprot.readI64();
11977 
        else:
11978 
          iprot.skip(ftype)
11979 
      elif fid == 3:
3064 chandransh 11980 
        if ftype == TType.STRING:
4394 rajveer 11981 
          self.description = iprot.readString();
3064 chandransh 11982 
        else:
11983 
          iprot.skip(ftype)
94 ashish 11984 
      else:
11985 
        iprot.skip(ftype)
11986 
      iprot.readFieldEnd()
11987 
    iprot.readStructEnd()
11988 
 
11989 
  def write(self, oprot):
11990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11992 
      return
4394 rajveer 11993 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11994 
    if self.type is not None:
4394 rajveer 11995 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11996 
      oprot.writeI64(self.type)
11997 
      oprot.writeFieldEnd()
4444 rajveer 11998 
    if self.warehouseId is not None:
11999 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12000 
      oprot.writeI64(self.warehouseId)
12001 
      oprot.writeFieldEnd()
4394 rajveer 12002 
    if self.description is not None:
4444 rajveer 12003 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12004 
      oprot.writeString(self.description)
3064 chandransh 12005 
      oprot.writeFieldEnd()
94 ashish 12006 
    oprot.writeFieldStop()
12007 
    oprot.writeStructEnd()
12008 
 
3431 rajveer 12009 
  def validate(self):
12010 
    return
12011 
 
12012 
 
94 ashish 12013 
  def __repr__(self):
12014 
    L = ['%s=%r' % (key, value)
12015 
      for key, value in self.__dict__.iteritems()]
12016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12017 
 
12018 
  def __eq__(self, other):
12019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12020 
 
12021 
  def __ne__(self, other):
12022 
    return not (self == other)
12023 
 
4394 rajveer 12024 
class addAlert_result:
3064 chandransh 12025 
 
12026 
  thrift_spec = (
12027 
  )
12028 
 
12029 
  def read(self, iprot):
12030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12032 
      return
12033 
    iprot.readStructBegin()
12034 
    while True:
12035 
      (fname, ftype, fid) = iprot.readFieldBegin()
12036 
      if ftype == TType.STOP:
12037 
        break
12038 
      else:
12039 
        iprot.skip(ftype)
12040 
      iprot.readFieldEnd()
12041 
    iprot.readStructEnd()
12042 
 
12043 
  def write(self, oprot):
12044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12046 
      return
4394 rajveer 12047 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12048 
    oprot.writeFieldStop()
12049 
    oprot.writeStructEnd()
12050 
 
3431 rajveer 12051 
  def validate(self):
12052 
    return
12053 
 
12054 
 
3064 chandransh 12055 
  def __repr__(self):
12056 
    L = ['%s=%r' % (key, value)
12057 
      for key, value in self.__dict__.iteritems()]
12058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12059 
 
12060 
  def __eq__(self, other):
12061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12062 
 
12063 
  def __ne__(self, other):
12064 
    return not (self == other)
12065 
 
4444 rajveer 12066 
class markAlertsAsSeen_args:
12067 
  """
12068 
  Attributes:
12069 
   - warehouseId
12070 
  """
12071 
 
12072 
  thrift_spec = (
12073 
    None, # 0
12074 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12075 
  )
12076 
 
12077 
  def __init__(self, warehouseId=None,):
12078 
    self.warehouseId = warehouseId
12079 
 
12080 
  def read(self, iprot):
12081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12083 
      return
12084 
    iprot.readStructBegin()
12085 
    while True:
12086 
      (fname, ftype, fid) = iprot.readFieldBegin()
12087 
      if ftype == TType.STOP:
12088 
        break
12089 
      if fid == 1:
12090 
        if ftype == TType.I64:
12091 
          self.warehouseId = iprot.readI64();
12092 
        else:
12093 
          iprot.skip(ftype)
12094 
      else:
12095 
        iprot.skip(ftype)
12096 
      iprot.readFieldEnd()
12097 
    iprot.readStructEnd()
12098 
 
12099 
  def write(self, oprot):
12100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12102 
      return
12103 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12104 
    if self.warehouseId is not None:
12105 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12106 
      oprot.writeI64(self.warehouseId)
12107 
      oprot.writeFieldEnd()
12108 
    oprot.writeFieldStop()
12109 
    oprot.writeStructEnd()
12110 
 
12111 
  def validate(self):
12112 
    return
12113 
 
12114 
 
12115 
  def __repr__(self):
12116 
    L = ['%s=%r' % (key, value)
12117 
      for key, value in self.__dict__.iteritems()]
12118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12119 
 
12120 
  def __eq__(self, other):
12121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12122 
 
12123 
  def __ne__(self, other):
12124 
    return not (self == other)
12125 
 
12126 
class markAlertsAsSeen_result:
12127 
 
12128 
  thrift_spec = (
12129 
  )
12130 
 
12131 
  def read(self, iprot):
12132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12134 
      return
12135 
    iprot.readStructBegin()
12136 
    while True:
12137 
      (fname, ftype, fid) = iprot.readFieldBegin()
12138 
      if ftype == TType.STOP:
12139 
        break
12140 
      else:
12141 
        iprot.skip(ftype)
12142 
      iprot.readFieldEnd()
12143 
    iprot.readStructEnd()
12144 
 
12145 
  def write(self, oprot):
12146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12148 
      return
12149 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12150 
    oprot.writeFieldStop()
12151 
    oprot.writeStructEnd()
12152 
 
12153 
  def validate(self):
12154 
    return
12155 
 
12156 
 
12157 
  def __repr__(self):
12158 
    L = ['%s=%r' % (key, value)
12159 
      for key, value in self.__dict__.iteritems()]
12160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12161 
 
12162 
  def __eq__(self, other):
12163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12164 
 
12165 
  def __ne__(self, other):
12166 
    return not (self == other)
12167 
 
3064 chandransh 12168 
class getValidOrderCount_args:
12169 
 
12170 
  thrift_spec = (
12171 
  )
12172 
 
12173 
  def read(self, iprot):
12174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12176 
      return
12177 
    iprot.readStructBegin()
12178 
    while True:
12179 
      (fname, ftype, fid) = iprot.readFieldBegin()
12180 
      if ftype == TType.STOP:
12181 
        break
12182 
      else:
12183 
        iprot.skip(ftype)
12184 
      iprot.readFieldEnd()
12185 
    iprot.readStructEnd()
12186 
 
12187 
  def write(self, oprot):
12188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12190 
      return
12191 
    oprot.writeStructBegin('getValidOrderCount_args')
12192 
    oprot.writeFieldStop()
12193 
    oprot.writeStructEnd()
12194 
 
3431 rajveer 12195 
  def validate(self):
12196 
    return
12197 
 
12198 
 
3064 chandransh 12199 
  def __repr__(self):
12200 
    L = ['%s=%r' % (key, value)
12201 
      for key, value in self.__dict__.iteritems()]
12202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12203 
 
12204 
  def __eq__(self, other):
12205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12206 
 
12207 
  def __ne__(self, other):
12208 
    return not (self == other)
12209 
 
12210 
class getValidOrderCount_result:
94 ashish 12211 
  """
12212 
  Attributes:
12213 
   - success
12214 
  """
12215 
 
12216 
  thrift_spec = (
3064 chandransh 12217 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12218 
  )
12219 
 
3064 chandransh 12220 
  def __init__(self, success=None,):
94 ashish 12221 
    self.success = success
12222 
 
12223 
  def read(self, iprot):
12224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12226 
      return
12227 
    iprot.readStructBegin()
12228 
    while True:
12229 
      (fname, ftype, fid) = iprot.readFieldBegin()
12230 
      if ftype == TType.STOP:
12231 
        break
12232 
      if fid == 0:
3064 chandransh 12233 
        if ftype == TType.I64:
12234 
          self.success = iprot.readI64();
94 ashish 12235 
        else:
12236 
          iprot.skip(ftype)
12237 
      else:
12238 
        iprot.skip(ftype)
12239 
      iprot.readFieldEnd()
12240 
    iprot.readStructEnd()
12241 
 
12242 
  def write(self, oprot):
12243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12245 
      return
3064 chandransh 12246 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12247 
    if self.success is not None:
3064 chandransh 12248 
      oprot.writeFieldBegin('success', TType.I64, 0)
12249 
      oprot.writeI64(self.success)
94 ashish 12250 
      oprot.writeFieldEnd()
12251 
    oprot.writeFieldStop()
12252 
    oprot.writeStructEnd()
12253 
 
3431 rajveer 12254 
  def validate(self):
12255 
    return
12256 
 
12257 
 
94 ashish 12258 
  def __repr__(self):
12259 
    L = ['%s=%r' % (key, value)
12260 
      for key, value in self.__dict__.iteritems()]
12261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12262 
 
12263 
  def __eq__(self, other):
12264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12265 
 
12266 
  def __ne__(self, other):
12267 
    return not (self == other)
12268 
 
3064 chandransh 12269 
class getNoOfCustomersWithSuccessfulTransaction_args:
12270 
 
12271 
  thrift_spec = (
12272 
  )
12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
12283 
      else:
12284 
        iprot.skip(ftype)
12285 
      iprot.readFieldEnd()
12286 
    iprot.readStructEnd()
12287 
 
12288 
  def write(self, oprot):
12289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12291 
      return
12292 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12293 
    oprot.writeFieldStop()
12294 
    oprot.writeStructEnd()
12295 
 
3431 rajveer 12296 
  def validate(self):
12297 
    return
12298 
 
12299 
 
3064 chandransh 12300 
  def __repr__(self):
12301 
    L = ['%s=%r' % (key, value)
12302 
      for key, value in self.__dict__.iteritems()]
12303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12304 
 
12305 
  def __eq__(self, other):
12306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12307 
 
12308 
  def __ne__(self, other):
12309 
    return not (self == other)
12310 
 
12311 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12312 
  """
12313 
  Attributes:
3064 chandransh 12314 
   - success
94 ashish 12315 
  """
12316 
 
12317 
  thrift_spec = (
3064 chandransh 12318 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12319 
  )
12320 
 
3064 chandransh 12321 
  def __init__(self, success=None,):
12322 
    self.success = success
94 ashish 12323 
 
12324 
  def read(self, iprot):
12325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12327 
      return
12328 
    iprot.readStructBegin()
12329 
    while True:
12330 
      (fname, ftype, fid) = iprot.readFieldBegin()
12331 
      if ftype == TType.STOP:
12332 
        break
3064 chandransh 12333 
      if fid == 0:
94 ashish 12334 
        if ftype == TType.I64:
3064 chandransh 12335 
          self.success = iprot.readI64();
94 ashish 12336 
        else:
12337 
          iprot.skip(ftype)
12338 
      else:
12339 
        iprot.skip(ftype)
12340 
      iprot.readFieldEnd()
12341 
    iprot.readStructEnd()
12342 
 
12343 
  def write(self, oprot):
12344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12346 
      return
3064 chandransh 12347 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12348 
    if self.success is not None:
3064 chandransh 12349 
      oprot.writeFieldBegin('success', TType.I64, 0)
12350 
      oprot.writeI64(self.success)
94 ashish 12351 
      oprot.writeFieldEnd()
12352 
    oprot.writeFieldStop()
12353 
    oprot.writeStructEnd()
12354 
 
3431 rajveer 12355 
  def validate(self):
12356 
    return
12357 
 
12358 
 
94 ashish 12359 
  def __repr__(self):
12360 
    L = ['%s=%r' % (key, value)
12361 
      for key, value in self.__dict__.iteritems()]
12362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12363 
 
12364 
  def __eq__(self, other):
12365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12366 
 
12367 
  def __ne__(self, other):
12368 
    return not (self == other)
12369 
 
3064 chandransh 12370 
class getValidOrdersAmountRange_args:
12371 
 
12372 
  thrift_spec = (
12373 
  )
12374 
 
12375 
  def read(self, iprot):
12376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12378 
      return
12379 
    iprot.readStructBegin()
12380 
    while True:
12381 
      (fname, ftype, fid) = iprot.readFieldBegin()
12382 
      if ftype == TType.STOP:
12383 
        break
12384 
      else:
12385 
        iprot.skip(ftype)
12386 
      iprot.readFieldEnd()
12387 
    iprot.readStructEnd()
12388 
 
12389 
  def write(self, oprot):
12390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12392 
      return
12393 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12394 
    oprot.writeFieldStop()
12395 
    oprot.writeStructEnd()
12396 
 
3431 rajveer 12397 
  def validate(self):
12398 
    return
12399 
 
12400 
 
3064 chandransh 12401 
  def __repr__(self):
12402 
    L = ['%s=%r' % (key, value)
12403 
      for key, value in self.__dict__.iteritems()]
12404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12405 
 
12406 
  def __eq__(self, other):
12407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12408 
 
12409 
  def __ne__(self, other):
12410 
    return not (self == other)
12411 
 
12412 
class getValidOrdersAmountRange_result:
94 ashish 12413 
  """
12414 
  Attributes:
12415 
   - success
12416 
  """
12417 
 
12418 
  thrift_spec = (
3064 chandransh 12419 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12420 
  )
12421 
 
3064 chandransh 12422 
  def __init__(self, success=None,):
94 ashish 12423 
    self.success = success
12424 
 
12425 
  def read(self, iprot):
12426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12428 
      return
12429 
    iprot.readStructBegin()
12430 
    while True:
12431 
      (fname, ftype, fid) = iprot.readFieldBegin()
12432 
      if ftype == TType.STOP:
12433 
        break
12434 
      if fid == 0:
483 rajveer 12435 
        if ftype == TType.LIST:
12436 
          self.success = []
6031 rajveer 12437 
          (_etype206, _size203) = iprot.readListBegin()
12438 
          for _i207 in xrange(_size203):
12439 
            _elem208 = iprot.readDouble();
12440 
            self.success.append(_elem208)
483 rajveer 12441 
          iprot.readListEnd()
94 ashish 12442 
        else:
12443 
          iprot.skip(ftype)
12444 
      else:
12445 
        iprot.skip(ftype)
12446 
      iprot.readFieldEnd()
12447 
    iprot.readStructEnd()
12448 
 
12449 
  def write(self, oprot):
12450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12452 
      return
3064 chandransh 12453 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12454 
    if self.success is not None:
483 rajveer 12455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12456 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6031 rajveer 12457 
      for iter209 in self.success:
12458 
        oprot.writeDouble(iter209)
483 rajveer 12459 
      oprot.writeListEnd()
94 ashish 12460 
      oprot.writeFieldEnd()
12461 
    oprot.writeFieldStop()
12462 
    oprot.writeStructEnd()
12463 
 
3431 rajveer 12464 
  def validate(self):
12465 
    return
12466 
 
12467 
 
94 ashish 12468 
  def __repr__(self):
12469 
    L = ['%s=%r' % (key, value)
12470 
      for key, value in self.__dict__.iteritems()]
12471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12472 
 
12473 
  def __eq__(self, other):
12474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12475 
 
12476 
  def __ne__(self, other):
12477 
    return not (self == other)
12478 
 
3064 chandransh 12479 
class getValidOrders_args:
1528 ankur.sing 12480 
  """
12481 
  Attributes:
3064 chandransh 12482 
   - limit
5874 rajveer 12483 
   - onlyStore
1528 ankur.sing 12484 
  """
12485 
 
12486 
  thrift_spec = (
12487 
    None, # 0
3064 chandransh 12488 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12489 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12490 
  )
12491 
 
5874 rajveer 12492 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12493 
    self.limit = limit
5874 rajveer 12494 
    self.onlyStore = onlyStore
1528 ankur.sing 12495 
 
12496 
  def read(self, iprot):
12497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12499 
      return
12500 
    iprot.readStructBegin()
12501 
    while True:
12502 
      (fname, ftype, fid) = iprot.readFieldBegin()
12503 
      if ftype == TType.STOP:
12504 
        break
12505 
      if fid == 1:
12506 
        if ftype == TType.I64:
3064 chandransh 12507 
          self.limit = iprot.readI64();
1528 ankur.sing 12508 
        else:
12509 
          iprot.skip(ftype)
5874 rajveer 12510 
      elif fid == 2:
12511 
        if ftype == TType.BOOL:
12512 
          self.onlyStore = iprot.readBool();
12513 
        else:
12514 
          iprot.skip(ftype)
1528 ankur.sing 12515 
      else:
12516 
        iprot.skip(ftype)
12517 
      iprot.readFieldEnd()
12518 
    iprot.readStructEnd()
12519 
 
12520 
  def write(self, oprot):
12521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12523 
      return
3064 chandransh 12524 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12525 
    if self.limit is not None:
3064 chandransh 12526 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12527 
      oprot.writeI64(self.limit)
1528 ankur.sing 12528 
      oprot.writeFieldEnd()
5874 rajveer 12529 
    if self.onlyStore is not None:
12530 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12531 
      oprot.writeBool(self.onlyStore)
12532 
      oprot.writeFieldEnd()
1528 ankur.sing 12533 
    oprot.writeFieldStop()
12534 
    oprot.writeStructEnd()
12535 
 
3431 rajveer 12536 
  def validate(self):
12537 
    return
12538 
 
12539 
 
1528 ankur.sing 12540 
  def __repr__(self):
12541 
    L = ['%s=%r' % (key, value)
12542 
      for key, value in self.__dict__.iteritems()]
12543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12544 
 
12545 
  def __eq__(self, other):
12546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12547 
 
12548 
  def __ne__(self, other):
12549 
    return not (self == other)
12550 
 
3064 chandransh 12551 
class getValidOrders_result:
1528 ankur.sing 12552 
  """
12553 
  Attributes:
12554 
   - success
12555 
  """
12556 
 
12557 
  thrift_spec = (
3064 chandransh 12558 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12559 
  )
12560 
 
3064 chandransh 12561 
  def __init__(self, success=None,):
1528 ankur.sing 12562 
    self.success = success
12563 
 
12564 
  def read(self, iprot):
12565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12567 
      return
12568 
    iprot.readStructBegin()
12569 
    while True:
12570 
      (fname, ftype, fid) = iprot.readFieldBegin()
12571 
      if ftype == TType.STOP:
12572 
        break
12573 
      if fid == 0:
3064 chandransh 12574 
        if ftype == TType.LIST:
12575 
          self.success = []
6031 rajveer 12576 
          (_etype213, _size210) = iprot.readListBegin()
12577 
          for _i214 in xrange(_size210):
12578 
            _elem215 = Order()
12579 
            _elem215.read(iprot)
12580 
            self.success.append(_elem215)
3064 chandransh 12581 
          iprot.readListEnd()
1528 ankur.sing 12582 
        else:
12583 
          iprot.skip(ftype)
12584 
      else:
12585 
        iprot.skip(ftype)
12586 
      iprot.readFieldEnd()
12587 
    iprot.readStructEnd()
12588 
 
12589 
  def write(self, oprot):
12590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12592 
      return
3064 chandransh 12593 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12594 
    if self.success is not None:
3064 chandransh 12595 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12596 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12597 
      for iter216 in self.success:
12598 
        iter216.write(oprot)
3064 chandransh 12599 
      oprot.writeListEnd()
1528 ankur.sing 12600 
      oprot.writeFieldEnd()
12601 
    oprot.writeFieldStop()
12602 
    oprot.writeStructEnd()
12603 
 
3431 rajveer 12604 
  def validate(self):
12605 
    return
12606 
 
12607 
 
1528 ankur.sing 12608 
  def __repr__(self):
12609 
    L = ['%s=%r' % (key, value)
12610 
      for key, value in self.__dict__.iteritems()]
12611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12612 
 
12613 
  def __eq__(self, other):
12614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12615 
 
12616 
  def __ne__(self, other):
12617 
    return not (self == other)
12618 
 
1220 chandransh 12619 
class batchOrders_args:
12620 
  """
12621 
  Attributes:
12622 
   - warehouseId
12623 
  """
12624 
 
12625 
  thrift_spec = (
12626 
    None, # 0
12627 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12628 
  )
12629 
 
12630 
  def __init__(self, warehouseId=None,):
12631 
    self.warehouseId = warehouseId
12632 
 
12633 
  def read(self, iprot):
12634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12636 
      return
12637 
    iprot.readStructBegin()
12638 
    while True:
12639 
      (fname, ftype, fid) = iprot.readFieldBegin()
12640 
      if ftype == TType.STOP:
12641 
        break
12642 
      if fid == 1:
12643 
        if ftype == TType.I64:
12644 
          self.warehouseId = iprot.readI64();
12645 
        else:
12646 
          iprot.skip(ftype)
12647 
      else:
12648 
        iprot.skip(ftype)
12649 
      iprot.readFieldEnd()
12650 
    iprot.readStructEnd()
12651 
 
12652 
  def write(self, oprot):
12653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12655 
      return
12656 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12657 
    if self.warehouseId is not None:
1220 chandransh 12658 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12659 
      oprot.writeI64(self.warehouseId)
12660 
      oprot.writeFieldEnd()
12661 
    oprot.writeFieldStop()
12662 
    oprot.writeStructEnd()
12663 
 
3431 rajveer 12664 
  def validate(self):
12665 
    return
12666 
 
12667 
 
1220 chandransh 12668 
  def __repr__(self):
12669 
    L = ['%s=%r' % (key, value)
12670 
      for key, value in self.__dict__.iteritems()]
12671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12672 
 
12673 
  def __eq__(self, other):
12674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12675 
 
12676 
  def __ne__(self, other):
12677 
    return not (self == other)
12678 
 
12679 
class batchOrders_result:
12680 
  """
12681 
  Attributes:
12682 
   - success
12683 
   - ex
12684 
  """
12685 
 
12686 
  thrift_spec = (
12687 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12689 
  )
12690 
 
12691 
  def __init__(self, success=None, ex=None,):
12692 
    self.success = success
12693 
    self.ex = ex
12694 
 
12695 
  def read(self, iprot):
12696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12698 
      return
12699 
    iprot.readStructBegin()
12700 
    while True:
12701 
      (fname, ftype, fid) = iprot.readFieldBegin()
12702 
      if ftype == TType.STOP:
12703 
        break
12704 
      if fid == 0:
12705 
        if ftype == TType.LIST:
12706 
          self.success = []
6031 rajveer 12707 
          (_etype220, _size217) = iprot.readListBegin()
12708 
          for _i221 in xrange(_size217):
12709 
            _elem222 = Order()
12710 
            _elem222.read(iprot)
12711 
            self.success.append(_elem222)
1220 chandransh 12712 
          iprot.readListEnd()
12713 
        else:
12714 
          iprot.skip(ftype)
12715 
      elif fid == 1:
12716 
        if ftype == TType.STRUCT:
12717 
          self.ex = TransactionServiceException()
12718 
          self.ex.read(iprot)
12719 
        else:
12720 
          iprot.skip(ftype)
12721 
      else:
12722 
        iprot.skip(ftype)
12723 
      iprot.readFieldEnd()
12724 
    iprot.readStructEnd()
12725 
 
12726 
  def write(self, oprot):
12727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12729 
      return
12730 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12731 
    if self.success is not None:
1220 chandransh 12732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12734 
      for iter223 in self.success:
12735 
        iter223.write(oprot)
1220 chandransh 12736 
      oprot.writeListEnd()
12737 
      oprot.writeFieldEnd()
3431 rajveer 12738 
    if self.ex is not None:
1220 chandransh 12739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12740 
      self.ex.write(oprot)
12741 
      oprot.writeFieldEnd()
12742 
    oprot.writeFieldStop()
12743 
    oprot.writeStructEnd()
12744 
 
3431 rajveer 12745 
  def validate(self):
12746 
    return
12747 
 
12748 
 
1220 chandransh 12749 
  def __repr__(self):
12750 
    L = ['%s=%r' % (key, value)
12751 
      for key, value in self.__dict__.iteritems()]
12752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12753 
 
12754 
  def __eq__(self, other):
12755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12756 
 
12757 
  def __ne__(self, other):
12758 
    return not (self == other)
12759 
 
1208 chandransh 12760 
class markOrderAsOutOfStock_args:
12761 
  """
12762 
  Attributes:
12763 
   - orderId
12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    None, # 0
12768 
    (1, TType.I64, 'orderId', None, None, ), # 1
12769 
  )
12770 
 
12771 
  def __init__(self, orderId=None,):
12772 
    self.orderId = orderId
12773 
 
12774 
  def read(self, iprot):
12775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12777 
      return
12778 
    iprot.readStructBegin()
12779 
    while True:
12780 
      (fname, ftype, fid) = iprot.readFieldBegin()
12781 
      if ftype == TType.STOP:
12782 
        break
12783 
      if fid == 1:
12784 
        if ftype == TType.I64:
12785 
          self.orderId = iprot.readI64();
12786 
        else:
12787 
          iprot.skip(ftype)
12788 
      else:
12789 
        iprot.skip(ftype)
12790 
      iprot.readFieldEnd()
12791 
    iprot.readStructEnd()
12792 
 
12793 
  def write(self, oprot):
12794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12796 
      return
12797 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12798 
    if self.orderId is not None:
1208 chandransh 12799 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12800 
      oprot.writeI64(self.orderId)
12801 
      oprot.writeFieldEnd()
12802 
    oprot.writeFieldStop()
12803 
    oprot.writeStructEnd()
12804 
 
3431 rajveer 12805 
  def validate(self):
12806 
    return
12807 
 
12808 
 
1208 chandransh 12809 
  def __repr__(self):
12810 
    L = ['%s=%r' % (key, value)
12811 
      for key, value in self.__dict__.iteritems()]
12812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12813 
 
12814 
  def __eq__(self, other):
12815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12816 
 
12817 
  def __ne__(self, other):
12818 
    return not (self == other)
12819 
 
12820 
class markOrderAsOutOfStock_result:
12821 
  """
12822 
  Attributes:
12823 
   - success
12824 
   - ex
12825 
  """
12826 
 
12827 
  thrift_spec = (
12828 
    (0, TType.BOOL, 'success', None, None, ), # 0
12829 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12830 
  )
12831 
 
12832 
  def __init__(self, success=None, ex=None,):
12833 
    self.success = success
12834 
    self.ex = ex
12835 
 
12836 
  def read(self, iprot):
12837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12839 
      return
12840 
    iprot.readStructBegin()
12841 
    while True:
12842 
      (fname, ftype, fid) = iprot.readFieldBegin()
12843 
      if ftype == TType.STOP:
12844 
        break
12845 
      if fid == 0:
12846 
        if ftype == TType.BOOL:
12847 
          self.success = iprot.readBool();
12848 
        else:
12849 
          iprot.skip(ftype)
12850 
      elif fid == 1:
12851 
        if ftype == TType.STRUCT:
12852 
          self.ex = TransactionServiceException()
12853 
          self.ex.read(iprot)
12854 
        else:
12855 
          iprot.skip(ftype)
12856 
      else:
12857 
        iprot.skip(ftype)
12858 
      iprot.readFieldEnd()
12859 
    iprot.readStructEnd()
12860 
 
12861 
  def write(self, oprot):
12862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12864 
      return
12865 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12866 
    if self.success is not None:
1208 chandransh 12867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12868 
      oprot.writeBool(self.success)
12869 
      oprot.writeFieldEnd()
3431 rajveer 12870 
    if self.ex is not None:
1208 chandransh 12871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12872 
      self.ex.write(oprot)
12873 
      oprot.writeFieldEnd()
12874 
    oprot.writeFieldStop()
12875 
    oprot.writeStructEnd()
12876 
 
3431 rajveer 12877 
  def validate(self):
12878 
    return
12879 
 
12880 
 
1208 chandransh 12881 
  def __repr__(self):
12882 
    L = ['%s=%r' % (key, value)
12883 
      for key, value in self.__dict__.iteritems()]
12884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12885 
 
12886 
  def __eq__(self, other):
12887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12888 
 
12889 
  def __ne__(self, other):
12890 
    return not (self == other)
12891 
 
3064 chandransh 12892 
class verifyOrder_args:
759 chandransh 12893 
  """
12894 
  Attributes:
3064 chandransh 12895 
   - orderId
759 chandransh 12896 
  """
12897 
 
12898 
  thrift_spec = (
12899 
    None, # 0
3064 chandransh 12900 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12901 
  )
12902 
 
3064 chandransh 12903 
  def __init__(self, orderId=None,):
12904 
    self.orderId = orderId
759 chandransh 12905 
 
12906 
  def read(self, iprot):
12907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12909 
      return
12910 
    iprot.readStructBegin()
12911 
    while True:
12912 
      (fname, ftype, fid) = iprot.readFieldBegin()
12913 
      if ftype == TType.STOP:
12914 
        break
12915 
      if fid == 1:
12916 
        if ftype == TType.I64:
3064 chandransh 12917 
          self.orderId = iprot.readI64();
759 chandransh 12918 
        else:
12919 
          iprot.skip(ftype)
12920 
      else:
12921 
        iprot.skip(ftype)
12922 
      iprot.readFieldEnd()
12923 
    iprot.readStructEnd()
12924 
 
12925 
  def write(self, oprot):
12926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12928 
      return
3064 chandransh 12929 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12930 
    if self.orderId is not None:
3064 chandransh 12931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12932 
      oprot.writeI64(self.orderId)
759 chandransh 12933 
      oprot.writeFieldEnd()
12934 
    oprot.writeFieldStop()
12935 
    oprot.writeStructEnd()
12936 
 
3431 rajveer 12937 
  def validate(self):
12938 
    return
12939 
 
12940 
 
759 chandransh 12941 
  def __repr__(self):
12942 
    L = ['%s=%r' % (key, value)
12943 
      for key, value in self.__dict__.iteritems()]
12944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12945 
 
12946 
  def __eq__(self, other):
12947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12948 
 
12949 
  def __ne__(self, other):
12950 
    return not (self == other)
12951 
 
3064 chandransh 12952 
class verifyOrder_result:
759 chandransh 12953 
  """
12954 
  Attributes:
12955 
   - success
12956 
   - ex
12957 
  """
12958 
 
12959 
  thrift_spec = (
12960 
    (0, TType.BOOL, 'success', None, None, ), # 0
12961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12962 
  )
12963 
 
12964 
  def __init__(self, success=None, ex=None,):
12965 
    self.success = success
12966 
    self.ex = ex
12967 
 
12968 
  def read(self, iprot):
12969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12971 
      return
12972 
    iprot.readStructBegin()
12973 
    while True:
12974 
      (fname, ftype, fid) = iprot.readFieldBegin()
12975 
      if ftype == TType.STOP:
12976 
        break
12977 
      if fid == 0:
12978 
        if ftype == TType.BOOL:
12979 
          self.success = iprot.readBool();
12980 
        else:
12981 
          iprot.skip(ftype)
12982 
      elif fid == 1:
12983 
        if ftype == TType.STRUCT:
12984 
          self.ex = TransactionServiceException()
12985 
          self.ex.read(iprot)
12986 
        else:
12987 
          iprot.skip(ftype)
12988 
      else:
12989 
        iprot.skip(ftype)
12990 
      iprot.readFieldEnd()
12991 
    iprot.readStructEnd()
12992 
 
12993 
  def write(self, oprot):
12994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12996 
      return
3064 chandransh 12997 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12998 
    if self.success is not None:
759 chandransh 12999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13000 
      oprot.writeBool(self.success)
13001 
      oprot.writeFieldEnd()
3431 rajveer 13002 
    if self.ex is not None:
759 chandransh 13003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13004 
      self.ex.write(oprot)
13005 
      oprot.writeFieldEnd()
13006 
    oprot.writeFieldStop()
13007 
    oprot.writeStructEnd()
13008 
 
3431 rajveer 13009 
  def validate(self):
13010 
    return
13011 
 
13012 
 
759 chandransh 13013 
  def __repr__(self):
13014 
    L = ['%s=%r' % (key, value)
13015 
      for key, value in self.__dict__.iteritems()]
13016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13017 
 
13018 
  def __eq__(self, other):
13019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13020 
 
13021 
  def __ne__(self, other):
13022 
    return not (self == other)
13023 
 
3064 chandransh 13024 
class acceptOrder_args:
1113 chandransh 13025 
  """
13026 
  Attributes:
3064 chandransh 13027 
   - orderId
1113 chandransh 13028 
  """
13029 
 
13030 
  thrift_spec = (
13031 
    None, # 0
3064 chandransh 13032 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13033 
  )
13034 
 
3064 chandransh 13035 
  def __init__(self, orderId=None,):
13036 
    self.orderId = orderId
1113 chandransh 13037 
 
13038 
  def read(self, iprot):
13039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13041 
      return
13042 
    iprot.readStructBegin()
13043 
    while True:
13044 
      (fname, ftype, fid) = iprot.readFieldBegin()
13045 
      if ftype == TType.STOP:
13046 
        break
13047 
      if fid == 1:
13048 
        if ftype == TType.I64:
3064 chandransh 13049 
          self.orderId = iprot.readI64();
1113 chandransh 13050 
        else:
13051 
          iprot.skip(ftype)
13052 
      else:
13053 
        iprot.skip(ftype)
13054 
      iprot.readFieldEnd()
13055 
    iprot.readStructEnd()
13056 
 
13057 
  def write(self, oprot):
13058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13060 
      return
3064 chandransh 13061 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13062 
    if self.orderId is not None:
3064 chandransh 13063 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13064 
      oprot.writeI64(self.orderId)
1113 chandransh 13065 
      oprot.writeFieldEnd()
13066 
    oprot.writeFieldStop()
13067 
    oprot.writeStructEnd()
13068 
 
3431 rajveer 13069 
  def validate(self):
13070 
    return
13071 
 
13072 
 
1113 chandransh 13073 
  def __repr__(self):
13074 
    L = ['%s=%r' % (key, value)
13075 
      for key, value in self.__dict__.iteritems()]
13076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13077 
 
13078 
  def __eq__(self, other):
13079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13080 
 
13081 
  def __ne__(self, other):
13082 
    return not (self == other)
13083 
 
3064 chandransh 13084 
class acceptOrder_result:
1113 chandransh 13085 
  """
13086 
  Attributes:
13087 
   - success
13088 
   - ex
13089 
  """
13090 
 
13091 
  thrift_spec = (
3064 chandransh 13092 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13094 
  )
13095 
 
13096 
  def __init__(self, success=None, ex=None,):
13097 
    self.success = success
13098 
    self.ex = ex
13099 
 
13100 
  def read(self, iprot):
13101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13103 
      return
13104 
    iprot.readStructBegin()
13105 
    while True:
13106 
      (fname, ftype, fid) = iprot.readFieldBegin()
13107 
      if ftype == TType.STOP:
13108 
        break
13109 
      if fid == 0:
3064 chandransh 13110 
        if ftype == TType.BOOL:
13111 
          self.success = iprot.readBool();
1113 chandransh 13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      elif fid == 1:
13115 
        if ftype == TType.STRUCT:
13116 
          self.ex = TransactionServiceException()
13117 
          self.ex.read(iprot)
13118 
        else:
13119 
          iprot.skip(ftype)
13120 
      else:
13121 
        iprot.skip(ftype)
13122 
      iprot.readFieldEnd()
13123 
    iprot.readStructEnd()
13124 
 
13125 
  def write(self, oprot):
13126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13128 
      return
3064 chandransh 13129 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13130 
    if self.success is not None:
3064 chandransh 13131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13132 
      oprot.writeBool(self.success)
1113 chandransh 13133 
      oprot.writeFieldEnd()
3431 rajveer 13134 
    if self.ex is not None:
1113 chandransh 13135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13136 
      self.ex.write(oprot)
13137 
      oprot.writeFieldEnd()
13138 
    oprot.writeFieldStop()
13139 
    oprot.writeStructEnd()
13140 
 
3431 rajveer 13141 
  def validate(self):
13142 
    return
13143 
 
13144 
 
1113 chandransh 13145 
  def __repr__(self):
13146 
    L = ['%s=%r' % (key, value)
13147 
      for key, value in self.__dict__.iteritems()]
13148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13149 
 
13150 
  def __eq__(self, other):
13151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13152 
 
13153 
  def __ne__(self, other):
13154 
    return not (self == other)
13155 
 
3064 chandransh 13156 
class addBillingDetails_args:
1135 chandransh 13157 
  """
13158 
  Attributes:
3064 chandransh 13159 
   - orderId
13160 
   - invoice_number
4658 mandeep.dh 13161 
   - serialNumber
4283 anupam.sin 13162 
   - itemNumber
3064 chandransh 13163 
   - billed_by
4264 rajveer 13164 
   - jacketNumber
4283 anupam.sin 13165 
   - billingType
5110 mandeep.dh 13166 
   - fulfilmentWarehouseId
4763 rajveer 13167 
   - authorize
1135 chandransh 13168 
  """
13169 
 
13170 
  thrift_spec = (
13171 
    None, # 0
3064 chandransh 13172 
    (1, TType.I64, 'orderId', None, None, ), # 1
13173 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13174 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13175 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13176 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13177 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13178 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13179 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13180 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13181 
  )
13182 
 
5110 mandeep.dh 13183 
  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 13184 
    self.orderId = orderId
13185 
    self.invoice_number = invoice_number
4658 mandeep.dh 13186 
    self.serialNumber = serialNumber
4283 anupam.sin 13187 
    self.itemNumber = itemNumber
3064 chandransh 13188 
    self.billed_by = billed_by
4264 rajveer 13189 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13190 
    self.billingType = billingType
5110 mandeep.dh 13191 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13192 
    self.authorize = authorize
1135 chandransh 13193 
 
13194 
  def read(self, iprot):
13195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13197 
      return
13198 
    iprot.readStructBegin()
13199 
    while True:
13200 
      (fname, ftype, fid) = iprot.readFieldBegin()
13201 
      if ftype == TType.STOP:
13202 
        break
13203 
      if fid == 1:
13204 
        if ftype == TType.I64:
3064 chandransh 13205 
          self.orderId = iprot.readI64();
1135 chandransh 13206 
        else:
13207 
          iprot.skip(ftype)
13208 
      elif fid == 2:
3064 chandransh 13209 
        if ftype == TType.STRING:
13210 
          self.invoice_number = iprot.readString();
1135 chandransh 13211 
        else:
13212 
          iprot.skip(ftype)
3064 chandransh 13213 
      elif fid == 3:
5411 rajveer 13214 
        if ftype == TType.LIST:
13215 
          self.serialNumber = []
6031 rajveer 13216 
          (_etype227, _size224) = iprot.readListBegin()
13217 
          for _i228 in xrange(_size224):
13218 
            _elem229 = iprot.readString();
13219 
            self.serialNumber.append(_elem229)
5411 rajveer 13220 
          iprot.readListEnd()
3064 chandransh 13221 
        else:
13222 
          iprot.skip(ftype)
13223 
      elif fid == 4:
5411 rajveer 13224 
        if ftype == TType.LIST:
13225 
          self.itemNumber = []
6031 rajveer 13226 
          (_etype233, _size230) = iprot.readListBegin()
13227 
          for _i234 in xrange(_size230):
13228 
            _elem235 = iprot.readString();
13229 
            self.itemNumber.append(_elem235)
5411 rajveer 13230 
          iprot.readListEnd()
3064 chandransh 13231 
        else:
13232 
          iprot.skip(ftype)
13233 
      elif fid == 5:
13234 
        if ftype == TType.STRING:
4283 anupam.sin 13235 
          self.billed_by = iprot.readString();
3064 chandransh 13236 
        else:
13237 
          iprot.skip(ftype)
13238 
      elif fid == 6:
13239 
        if ftype == TType.I64:
4283 anupam.sin 13240 
          self.jacketNumber = iprot.readI64();
13241 
        else:
13242 
          iprot.skip(ftype)
13243 
      elif fid == 7:
13244 
        if ftype == TType.I64:
3064 chandransh 13245 
          self.billingType = iprot.readI64();
13246 
        else:
13247 
          iprot.skip(ftype)
4283 anupam.sin 13248 
      elif fid == 8:
13249 
        if ftype == TType.I64:
5110 mandeep.dh 13250 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13251 
        else:
13252 
          iprot.skip(ftype)
4763 rajveer 13253 
      elif fid == 9:
13254 
        if ftype == TType.BOOL:
13255 
          self.authorize = iprot.readBool();
13256 
        else:
13257 
          iprot.skip(ftype)
1246 chandransh 13258 
      else:
13259 
        iprot.skip(ftype)
13260 
      iprot.readFieldEnd()
13261 
    iprot.readStructEnd()
13262 
 
13263 
  def write(self, oprot):
13264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13266 
      return
4283 anupam.sin 13267 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13268 
    if self.orderId is not None:
3064 chandransh 13269 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13270 
      oprot.writeI64(self.orderId)
1246 chandransh 13271 
      oprot.writeFieldEnd()
4283 anupam.sin 13272 
    if self.invoice_number is not None:
13273 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13274 
      oprot.writeString(self.invoice_number)
1246 chandransh 13275 
      oprot.writeFieldEnd()
4658 mandeep.dh 13276 
    if self.serialNumber is not None:
5411 rajveer 13277 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13278 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6031 rajveer 13279 
      for iter236 in self.serialNumber:
13280 
        oprot.writeString(iter236)
5411 rajveer 13281 
      oprot.writeListEnd()
3064 chandransh 13282 
      oprot.writeFieldEnd()
3431 rajveer 13283 
    if self.itemNumber is not None:
5411 rajveer 13284 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13285 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6031 rajveer 13286 
      for iter237 in self.itemNumber:
13287 
        oprot.writeString(iter237)
5411 rajveer 13288 
      oprot.writeListEnd()
3064 chandransh 13289 
      oprot.writeFieldEnd()
4283 anupam.sin 13290 
    if self.billed_by is not None:
13291 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13292 
      oprot.writeString(self.billed_by)
3064 chandransh 13293 
      oprot.writeFieldEnd()
4283 anupam.sin 13294 
    if self.jacketNumber is not None:
13295 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13296 
      oprot.writeI64(self.jacketNumber)
13297 
      oprot.writeFieldEnd()
3431 rajveer 13298 
    if self.billingType is not None:
4283 anupam.sin 13299 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13300 
      oprot.writeI64(self.billingType)
13301 
      oprot.writeFieldEnd()
5110 mandeep.dh 13302 
    if self.fulfilmentWarehouseId is not None:
13303 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13304 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13305 
      oprot.writeFieldEnd()
4763 rajveer 13306 
    if self.authorize is not None:
13307 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13308 
      oprot.writeBool(self.authorize)
13309 
      oprot.writeFieldEnd()
1246 chandransh 13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
3431 rajveer 13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
1246 chandransh 13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
13327 
 
4283 anupam.sin 13328 
class addBillingDetails_result:
1246 chandransh 13329 
  """
13330 
  Attributes:
3064 chandransh 13331 
   - success
1246 chandransh 13332 
   - ex
13333 
  """
13334 
 
13335 
  thrift_spec = (
3064 chandransh 13336 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13338 
  )
13339 
 
3064 chandransh 13340 
  def __init__(self, success=None, ex=None,):
13341 
    self.success = success
1246 chandransh 13342 
    self.ex = ex
13343 
 
13344 
  def read(self, iprot):
13345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13347 
      return
13348 
    iprot.readStructBegin()
13349 
    while True:
13350 
      (fname, ftype, fid) = iprot.readFieldBegin()
13351 
      if ftype == TType.STOP:
13352 
        break
3064 chandransh 13353 
      if fid == 0:
13354 
        if ftype == TType.BOOL:
13355 
          self.success = iprot.readBool();
13356 
        else:
13357 
          iprot.skip(ftype)
13358 
      elif fid == 1:
1246 chandransh 13359 
        if ftype == TType.STRUCT:
13360 
          self.ex = TransactionServiceException()
13361 
          self.ex.read(iprot)
13362 
        else:
13363 
          iprot.skip(ftype)
13364 
      else:
13365 
        iprot.skip(ftype)
13366 
      iprot.readFieldEnd()
13367 
    iprot.readStructEnd()
13368 
 
13369 
  def write(self, oprot):
13370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13372 
      return
4283 anupam.sin 13373 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13374 
    if self.success is not None:
3064 chandransh 13375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13376 
      oprot.writeBool(self.success)
13377 
      oprot.writeFieldEnd()
3431 rajveer 13378 
    if self.ex is not None:
1246 chandransh 13379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13380 
      self.ex.write(oprot)
13381 
      oprot.writeFieldEnd()
13382 
    oprot.writeFieldStop()
13383 
    oprot.writeStructEnd()
13384 
 
3431 rajveer 13385 
  def validate(self):
13386 
    return
13387 
 
13388 
 
1246 chandransh 13389 
  def __repr__(self):
13390 
    L = ['%s=%r' % (key, value)
13391 
      for key, value in self.__dict__.iteritems()]
13392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13393 
 
13394 
  def __eq__(self, other):
13395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13396 
 
13397 
  def __ne__(self, other):
13398 
    return not (self == other)
13399 
 
4579 rajveer 13400 
class addInvoiceNumber_args:
13401 
  """
13402 
  Attributes:
13403 
   - orderId
13404 
   - invoiceNumber
4763 rajveer 13405 
   - color
4579 rajveer 13406 
  """
13407 
 
13408 
  thrift_spec = (
13409 
    None, # 0
13410 
    (1, TType.I64, 'orderId', None, None, ), # 1
13411 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13412 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13413 
  )
13414 
 
4763 rajveer 13415 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13416 
    self.orderId = orderId
13417 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13418 
    self.color = color
4579 rajveer 13419 
 
13420 
  def read(self, iprot):
13421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13423 
      return
13424 
    iprot.readStructBegin()
13425 
    while True:
13426 
      (fname, ftype, fid) = iprot.readFieldBegin()
13427 
      if ftype == TType.STOP:
13428 
        break
13429 
      if fid == 1:
13430 
        if ftype == TType.I64:
13431 
          self.orderId = iprot.readI64();
13432 
        else:
13433 
          iprot.skip(ftype)
13434 
      elif fid == 2:
13435 
        if ftype == TType.STRING:
13436 
          self.invoiceNumber = iprot.readString();
13437 
        else:
13438 
          iprot.skip(ftype)
4763 rajveer 13439 
      elif fid == 3:
13440 
        if ftype == TType.STRING:
13441 
          self.color = iprot.readString();
13442 
        else:
13443 
          iprot.skip(ftype)
4579 rajveer 13444 
      else:
13445 
        iprot.skip(ftype)
13446 
      iprot.readFieldEnd()
13447 
    iprot.readStructEnd()
13448 
 
13449 
  def write(self, oprot):
13450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13452 
      return
13453 
    oprot.writeStructBegin('addInvoiceNumber_args')
13454 
    if self.orderId is not None:
13455 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13456 
      oprot.writeI64(self.orderId)
13457 
      oprot.writeFieldEnd()
13458 
    if self.invoiceNumber is not None:
13459 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13460 
      oprot.writeString(self.invoiceNumber)
13461 
      oprot.writeFieldEnd()
4763 rajveer 13462 
    if self.color is not None:
13463 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13464 
      oprot.writeString(self.color)
13465 
      oprot.writeFieldEnd()
4579 rajveer 13466 
    oprot.writeFieldStop()
13467 
    oprot.writeStructEnd()
13468 
 
13469 
  def validate(self):
13470 
    return
13471 
 
13472 
 
13473 
  def __repr__(self):
13474 
    L = ['%s=%r' % (key, value)
13475 
      for key, value in self.__dict__.iteritems()]
13476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13477 
 
13478 
  def __eq__(self, other):
13479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13480 
 
13481 
  def __ne__(self, other):
13482 
    return not (self == other)
13483 
 
13484 
class addInvoiceNumber_result:
13485 
  """
13486 
  Attributes:
13487 
   - ex
13488 
  """
13489 
 
13490 
  thrift_spec = (
13491 
    None, # 0
13492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13493 
  )
13494 
 
13495 
  def __init__(self, ex=None,):
13496 
    self.ex = ex
13497 
 
13498 
  def read(self, iprot):
13499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13501 
      return
13502 
    iprot.readStructBegin()
13503 
    while True:
13504 
      (fname, ftype, fid) = iprot.readFieldBegin()
13505 
      if ftype == TType.STOP:
13506 
        break
13507 
      if fid == 1:
13508 
        if ftype == TType.STRUCT:
13509 
          self.ex = TransactionServiceException()
13510 
          self.ex.read(iprot)
13511 
        else:
13512 
          iprot.skip(ftype)
13513 
      else:
13514 
        iprot.skip(ftype)
13515 
      iprot.readFieldEnd()
13516 
    iprot.readStructEnd()
13517 
 
13518 
  def write(self, oprot):
13519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13521 
      return
13522 
    oprot.writeStructBegin('addInvoiceNumber_result')
13523 
    if self.ex is not None:
13524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13525 
      self.ex.write(oprot)
13526 
      oprot.writeFieldEnd()
13527 
    oprot.writeFieldStop()
13528 
    oprot.writeStructEnd()
13529 
 
13530 
  def validate(self):
13531 
    return
13532 
 
13533 
 
13534 
  def __repr__(self):
13535 
    L = ['%s=%r' % (key, value)
13536 
      for key, value in self.__dict__.iteritems()]
13537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13538 
 
13539 
  def __eq__(self, other):
13540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13541 
 
13542 
  def __ne__(self, other):
13543 
    return not (self == other)
13544 
 
4910 phani.kuma 13545 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13546 
  """
13547 
  Attributes:
3064 chandransh 13548 
   - warehouseId
1408 ankur.sing 13549 
   - providerId
3064 chandransh 13550 
   - cod
4910 phani.kuma 13551 
   - orderIds
1408 ankur.sing 13552 
  """
13553 
 
13554 
  thrift_spec = (
13555 
    None, # 0
3064 chandransh 13556 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13557 
    (2, TType.I64, 'providerId', None, None, ), # 2
13558 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13559 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13560 
  )
13561 
 
4910 phani.kuma 13562 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13563 
    self.warehouseId = warehouseId
1408 ankur.sing 13564 
    self.providerId = providerId
3064 chandransh 13565 
    self.cod = cod
4910 phani.kuma 13566 
    self.orderIds = orderIds
1408 ankur.sing 13567 
 
13568 
  def read(self, iprot):
13569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13571 
      return
13572 
    iprot.readStructBegin()
13573 
    while True:
13574 
      (fname, ftype, fid) = iprot.readFieldBegin()
13575 
      if ftype == TType.STOP:
13576 
        break
13577 
      if fid == 1:
13578 
        if ftype == TType.I64:
3064 chandransh 13579 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13580 
        else:
13581 
          iprot.skip(ftype)
13582 
      elif fid == 2:
13583 
        if ftype == TType.I64:
3064 chandransh 13584 
          self.providerId = iprot.readI64();
1408 ankur.sing 13585 
        else:
13586 
          iprot.skip(ftype)
3064 chandransh 13587 
      elif fid == 3:
13588 
        if ftype == TType.BOOL:
13589 
          self.cod = iprot.readBool();
13590 
        else:
13591 
          iprot.skip(ftype)
4910 phani.kuma 13592 
      elif fid == 4:
13593 
        if ftype == TType.LIST:
13594 
          self.orderIds = []
6031 rajveer 13595 
          (_etype241, _size238) = iprot.readListBegin()
13596 
          for _i242 in xrange(_size238):
13597 
            _elem243 = iprot.readI64();
13598 
            self.orderIds.append(_elem243)
4910 phani.kuma 13599 
          iprot.readListEnd()
13600 
        else:
13601 
          iprot.skip(ftype)
1408 ankur.sing 13602 
      else:
13603 
        iprot.skip(ftype)
13604 
      iprot.readFieldEnd()
13605 
    iprot.readStructEnd()
13606 
 
13607 
  def write(self, oprot):
13608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13610 
      return
4910 phani.kuma 13611 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13612 
    if self.warehouseId is not None:
3064 chandransh 13613 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13614 
      oprot.writeI64(self.warehouseId)
13615 
      oprot.writeFieldEnd()
3431 rajveer 13616 
    if self.providerId is not None:
3064 chandransh 13617 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13618 
      oprot.writeI64(self.providerId)
13619 
      oprot.writeFieldEnd()
3431 rajveer 13620 
    if self.cod is not None:
3064 chandransh 13621 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13622 
      oprot.writeBool(self.cod)
1408 ankur.sing 13623 
      oprot.writeFieldEnd()
4910 phani.kuma 13624 
    if self.orderIds is not None:
13625 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13626 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13627 
      for iter244 in self.orderIds:
13628 
        oprot.writeI64(iter244)
4910 phani.kuma 13629 
      oprot.writeListEnd()
13630 
      oprot.writeFieldEnd()
1408 ankur.sing 13631 
    oprot.writeFieldStop()
13632 
    oprot.writeStructEnd()
13633 
 
3431 rajveer 13634 
  def validate(self):
13635 
    return
13636 
 
13637 
 
1408 ankur.sing 13638 
  def __repr__(self):
13639 
    L = ['%s=%r' % (key, value)
13640 
      for key, value in self.__dict__.iteritems()]
13641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13642 
 
13643 
  def __eq__(self, other):
13644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13645 
 
13646 
  def __ne__(self, other):
13647 
    return not (self == other)
13648 
 
4910 phani.kuma 13649 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13650 
  """
13651 
  Attributes:
13652 
   - success
3064 chandransh 13653 
   - ex
1408 ankur.sing 13654 
  """
13655 
 
13656 
  thrift_spec = (
3064 chandransh 13657 
    (0, TType.BOOL, 'success', None, None, ), # 0
13658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13659 
  )
13660 
 
3064 chandransh 13661 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13662 
    self.success = success
3064 chandransh 13663 
    self.ex = ex
1408 ankur.sing 13664 
 
13665 
  def read(self, iprot):
13666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13668 
      return
13669 
    iprot.readStructBegin()
13670 
    while True:
13671 
      (fname, ftype, fid) = iprot.readFieldBegin()
13672 
      if ftype == TType.STOP:
13673 
        break
13674 
      if fid == 0:
3064 chandransh 13675 
        if ftype == TType.BOOL:
13676 
          self.success = iprot.readBool();
1408 ankur.sing 13677 
        else:
13678 
          iprot.skip(ftype)
3064 chandransh 13679 
      elif fid == 1:
13680 
        if ftype == TType.STRUCT:
13681 
          self.ex = TransactionServiceException()
13682 
          self.ex.read(iprot)
13683 
        else:
13684 
          iprot.skip(ftype)
1408 ankur.sing 13685 
      else:
13686 
        iprot.skip(ftype)
13687 
      iprot.readFieldEnd()
13688 
    iprot.readStructEnd()
13689 
 
13690 
  def write(self, oprot):
13691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13693 
      return
4910 phani.kuma 13694 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13695 
    if self.success is not None:
3064 chandransh 13696 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13697 
      oprot.writeBool(self.success)
1408 ankur.sing 13698 
      oprot.writeFieldEnd()
3431 rajveer 13699 
    if self.ex is not None:
3064 chandransh 13700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13701 
      self.ex.write(oprot)
13702 
      oprot.writeFieldEnd()
1408 ankur.sing 13703 
    oprot.writeFieldStop()
13704 
    oprot.writeStructEnd()
13705 
 
3431 rajveer 13706 
  def validate(self):
13707 
    return
13708 
 
13709 
 
1408 ankur.sing 13710 
  def __repr__(self):
13711 
    L = ['%s=%r' % (key, value)
13712 
      for key, value in self.__dict__.iteritems()]
13713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13714 
 
13715 
  def __eq__(self, other):
13716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13717 
 
13718 
  def __ne__(self, other):
13719 
    return not (self == other)
13720 
 
5676 rajveer 13721 
class markOrdersAsReturnedFromStore_args:
13722 
  """
13723 
  Attributes:
13724 
   - providerId
13725 
   - orderIds
5713 rajveer 13726 
   - awbs
5676 rajveer 13727 
  """
13728 
 
13729 
  thrift_spec = (
13730 
    None, # 0
13731 
    (1, TType.I64, 'providerId', None, None, ), # 1
13732 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13733 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13734 
  )
13735 
 
5713 rajveer 13736 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13737 
    self.providerId = providerId
13738 
    self.orderIds = orderIds
5713 rajveer 13739 
    self.awbs = awbs
5676 rajveer 13740 
 
13741 
  def read(self, iprot):
13742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13744 
      return
13745 
    iprot.readStructBegin()
13746 
    while True:
13747 
      (fname, ftype, fid) = iprot.readFieldBegin()
13748 
      if ftype == TType.STOP:
13749 
        break
13750 
      if fid == 1:
13751 
        if ftype == TType.I64:
13752 
          self.providerId = iprot.readI64();
13753 
        else:
13754 
          iprot.skip(ftype)
13755 
      elif fid == 2:
13756 
        if ftype == TType.LIST:
13757 
          self.orderIds = []
6031 rajveer 13758 
          (_etype248, _size245) = iprot.readListBegin()
13759 
          for _i249 in xrange(_size245):
13760 
            _elem250 = iprot.readI64();
13761 
            self.orderIds.append(_elem250)
5676 rajveer 13762 
          iprot.readListEnd()
13763 
        else:
13764 
          iprot.skip(ftype)
5713 rajveer 13765 
      elif fid == 3:
13766 
        if ftype == TType.LIST:
13767 
          self.awbs = []
6031 rajveer 13768 
          (_etype254, _size251) = iprot.readListBegin()
13769 
          for _i255 in xrange(_size251):
13770 
            _elem256 = iprot.readString();
13771 
            self.awbs.append(_elem256)
5713 rajveer 13772 
          iprot.readListEnd()
13773 
        else:
13774 
          iprot.skip(ftype)
5676 rajveer 13775 
      else:
13776 
        iprot.skip(ftype)
13777 
      iprot.readFieldEnd()
13778 
    iprot.readStructEnd()
13779 
 
13780 
  def write(self, oprot):
13781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13783 
      return
13784 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13785 
    if self.providerId is not None:
13786 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13787 
      oprot.writeI64(self.providerId)
13788 
      oprot.writeFieldEnd()
13789 
    if self.orderIds is not None:
13790 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13791 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13792 
      for iter257 in self.orderIds:
13793 
        oprot.writeI64(iter257)
5676 rajveer 13794 
      oprot.writeListEnd()
13795 
      oprot.writeFieldEnd()
5713 rajveer 13796 
    if self.awbs is not None:
13797 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13798 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6031 rajveer 13799 
      for iter258 in self.awbs:
13800 
        oprot.writeString(iter258)
5713 rajveer 13801 
      oprot.writeListEnd()
13802 
      oprot.writeFieldEnd()
5676 rajveer 13803 
    oprot.writeFieldStop()
13804 
    oprot.writeStructEnd()
13805 
 
13806 
  def validate(self):
13807 
    return
13808 
 
13809 
 
13810 
  def __repr__(self):
13811 
    L = ['%s=%r' % (key, value)
13812 
      for key, value in self.__dict__.iteritems()]
13813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13814 
 
13815 
  def __eq__(self, other):
13816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13817 
 
13818 
  def __ne__(self, other):
13819 
    return not (self == other)
13820 
 
13821 
class markOrdersAsReturnedFromStore_result:
13822 
  """
13823 
  Attributes:
13824 
   - success
13825 
   - ex
13826 
  """
13827 
 
13828 
  thrift_spec = (
13829 
    (0, TType.BOOL, 'success', None, None, ), # 0
13830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13831 
  )
13832 
 
13833 
  def __init__(self, success=None, ex=None,):
13834 
    self.success = success
13835 
    self.ex = ex
13836 
 
13837 
  def read(self, iprot):
13838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13840 
      return
13841 
    iprot.readStructBegin()
13842 
    while True:
13843 
      (fname, ftype, fid) = iprot.readFieldBegin()
13844 
      if ftype == TType.STOP:
13845 
        break
13846 
      if fid == 0:
13847 
        if ftype == TType.BOOL:
13848 
          self.success = iprot.readBool();
13849 
        else:
13850 
          iprot.skip(ftype)
13851 
      elif fid == 1:
13852 
        if ftype == TType.STRUCT:
13853 
          self.ex = TransactionServiceException()
13854 
          self.ex.read(iprot)
13855 
        else:
13856 
          iprot.skip(ftype)
13857 
      else:
13858 
        iprot.skip(ftype)
13859 
      iprot.readFieldEnd()
13860 
    iprot.readStructEnd()
13861 
 
13862 
  def write(self, oprot):
13863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13865 
      return
13866 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13867 
    if self.success is not None:
13868 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13869 
      oprot.writeBool(self.success)
13870 
      oprot.writeFieldEnd()
13871 
    if self.ex is not None:
13872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13873 
      self.ex.write(oprot)
13874 
      oprot.writeFieldEnd()
13875 
    oprot.writeFieldStop()
13876 
    oprot.writeStructEnd()
13877 
 
13878 
  def validate(self):
13879 
    return
13880 
 
13881 
 
13882 
  def __repr__(self):
13883 
    L = ['%s=%r' % (key, value)
13884 
      for key, value in self.__dict__.iteritems()]
13885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13886 
 
13887 
  def __eq__(self, other):
13888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13889 
 
13890 
  def __ne__(self, other):
13891 
    return not (self == other)
13892 
 
4910 phani.kuma 13893 
class markOrdersAsPickedUp_args:
4410 rajveer 13894 
  """
13895 
  Attributes:
13896 
   - providerId
4910 phani.kuma 13897 
   - pickupDetails
4410 rajveer 13898 
  """
13899 
 
13900 
  thrift_spec = (
13901 
    None, # 0
4910 phani.kuma 13902 
    (1, TType.I64, 'providerId', None, None, ), # 1
13903 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13904 
  )
13905 
 
4910 phani.kuma 13906 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13907 
    self.providerId = providerId
4910 phani.kuma 13908 
    self.pickupDetails = pickupDetails
4410 rajveer 13909 
 
13910 
  def read(self, iprot):
13911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13913 
      return
13914 
    iprot.readStructBegin()
13915 
    while True:
13916 
      (fname, ftype, fid) = iprot.readFieldBegin()
13917 
      if ftype == TType.STOP:
13918 
        break
13919 
      if fid == 1:
13920 
        if ftype == TType.I64:
4910 phani.kuma 13921 
          self.providerId = iprot.readI64();
4410 rajveer 13922 
        else:
13923 
          iprot.skip(ftype)
13924 
      elif fid == 2:
4910 phani.kuma 13925 
        if ftype == TType.MAP:
13926 
          self.pickupDetails = {}
6031 rajveer 13927 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13928 
          for _i263 in xrange(_size259):
13929 
            _key264 = iprot.readString();
13930 
            _val265 = iprot.readString();
13931 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13932 
          iprot.readMapEnd()
4410 rajveer 13933 
        else:
13934 
          iprot.skip(ftype)
13935 
      else:
13936 
        iprot.skip(ftype)
13937 
      iprot.readFieldEnd()
13938 
    iprot.readStructEnd()
13939 
 
13940 
  def write(self, oprot):
13941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13943 
      return
4910 phani.kuma 13944 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13945 
    if self.providerId is not None:
4910 phani.kuma 13946 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13947 
      oprot.writeI64(self.providerId)
13948 
      oprot.writeFieldEnd()
4910 phani.kuma 13949 
    if self.pickupDetails is not None:
13950 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13951 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 13952 
      for kiter266,viter267 in self.pickupDetails.items():
13953 
        oprot.writeString(kiter266)
13954 
        oprot.writeString(viter267)
4910 phani.kuma 13955 
      oprot.writeMapEnd()
4410 rajveer 13956 
      oprot.writeFieldEnd()
13957 
    oprot.writeFieldStop()
13958 
    oprot.writeStructEnd()
13959 
 
13960 
  def validate(self):
13961 
    return
13962 
 
13963 
 
13964 
  def __repr__(self):
13965 
    L = ['%s=%r' % (key, value)
13966 
      for key, value in self.__dict__.iteritems()]
13967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13968 
 
13969 
  def __eq__(self, other):
13970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13971 
 
13972 
  def __ne__(self, other):
13973 
    return not (self == other)
13974 
 
4910 phani.kuma 13975 
class markOrdersAsPickedUp_result:
4410 rajveer 13976 
  """
13977 
  Attributes:
13978 
   - ex
13979 
  """
13980 
 
13981 
  thrift_spec = (
4910 phani.kuma 13982 
    None, # 0
4410 rajveer 13983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13984 
  )
13985 
 
4910 phani.kuma 13986 
  def __init__(self, ex=None,):
4410 rajveer 13987 
    self.ex = ex
13988 
 
13989 
  def read(self, iprot):
13990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13992 
      return
13993 
    iprot.readStructBegin()
13994 
    while True:
13995 
      (fname, ftype, fid) = iprot.readFieldBegin()
13996 
      if ftype == TType.STOP:
13997 
        break
4910 phani.kuma 13998 
      if fid == 1:
4410 rajveer 13999 
        if ftype == TType.STRUCT:
14000 
          self.ex = TransactionServiceException()
14001 
          self.ex.read(iprot)
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      else:
14005 
        iprot.skip(ftype)
14006 
      iprot.readFieldEnd()
14007 
    iprot.readStructEnd()
14008 
 
14009 
  def write(self, oprot):
14010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14012 
      return
4910 phani.kuma 14013 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14014 
    if self.ex is not None:
14015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14016 
      self.ex.write(oprot)
14017 
      oprot.writeFieldEnd()
14018 
    oprot.writeFieldStop()
14019 
    oprot.writeStructEnd()
14020 
 
14021 
  def validate(self):
14022 
    return
14023 
 
14024 
 
14025 
  def __repr__(self):
14026 
    L = ['%s=%r' % (key, value)
14027 
      for key, value in self.__dict__.iteritems()]
14028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14029 
 
14030 
  def __eq__(self, other):
14031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14032 
 
14033 
  def __ne__(self, other):
14034 
    return not (self == other)
14035 
 
4910 phani.kuma 14036 
class getOrdersNotPickedUp_args:
304 ashish 14037 
  """
14038 
  Attributes:
3064 chandransh 14039 
   - providerId
304 ashish 14040 
  """
94 ashish 14041 
 
304 ashish 14042 
  thrift_spec = (
14043 
    None, # 0
3064 chandransh 14044 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14045 
  )
14046 
 
4910 phani.kuma 14047 
  def __init__(self, providerId=None,):
3064 chandransh 14048 
    self.providerId = providerId
304 ashish 14049 
 
14050 
  def read(self, iprot):
14051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14053 
      return
14054 
    iprot.readStructBegin()
14055 
    while True:
14056 
      (fname, ftype, fid) = iprot.readFieldBegin()
14057 
      if ftype == TType.STOP:
14058 
        break
14059 
      if fid == 1:
14060 
        if ftype == TType.I64:
3064 chandransh 14061 
          self.providerId = iprot.readI64();
304 ashish 14062 
        else:
14063 
          iprot.skip(ftype)
14064 
      else:
14065 
        iprot.skip(ftype)
14066 
      iprot.readFieldEnd()
14067 
    iprot.readStructEnd()
14068 
 
14069 
  def write(self, oprot):
14070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14072 
      return
4910 phani.kuma 14073 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14074 
    if self.providerId is not None:
3064 chandransh 14075 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14076 
      oprot.writeI64(self.providerId)
304 ashish 14077 
      oprot.writeFieldEnd()
14078 
    oprot.writeFieldStop()
14079 
    oprot.writeStructEnd()
14080 
 
3431 rajveer 14081 
  def validate(self):
14082 
    return
14083 
 
14084 
 
304 ashish 14085 
  def __repr__(self):
14086 
    L = ['%s=%r' % (key, value)
14087 
      for key, value in self.__dict__.iteritems()]
14088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14089 
 
14090 
  def __eq__(self, other):
14091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14092 
 
14093 
  def __ne__(self, other):
14094 
    return not (self == other)
14095 
 
4910 phani.kuma 14096 
class getOrdersNotPickedUp_result:
304 ashish 14097 
  """
14098 
  Attributes:
14099 
   - success
14100 
  """
14101 
 
14102 
  thrift_spec = (
3064 chandransh 14103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14104 
  )
14105 
 
4910 phani.kuma 14106 
  def __init__(self, success=None,):
304 ashish 14107 
    self.success = success
14108 
 
14109 
  def read(self, iprot):
14110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14112 
      return
14113 
    iprot.readStructBegin()
14114 
    while True:
14115 
      (fname, ftype, fid) = iprot.readFieldBegin()
14116 
      if ftype == TType.STOP:
14117 
        break
14118 
      if fid == 0:
14119 
        if ftype == TType.LIST:
14120 
          self.success = []
6031 rajveer 14121 
          (_etype271, _size268) = iprot.readListBegin()
14122 
          for _i272 in xrange(_size268):
14123 
            _elem273 = Order()
14124 
            _elem273.read(iprot)
14125 
            self.success.append(_elem273)
304 ashish 14126 
          iprot.readListEnd()
14127 
        else:
14128 
          iprot.skip(ftype)
14129 
      else:
14130 
        iprot.skip(ftype)
14131 
      iprot.readFieldEnd()
14132 
    iprot.readStructEnd()
14133 
 
14134 
  def write(self, oprot):
14135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14137 
      return
4910 phani.kuma 14138 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14139 
    if self.success is not None:
304 ashish 14140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14142 
      for iter274 in self.success:
14143 
        iter274.write(oprot)
304 ashish 14144 
      oprot.writeListEnd()
14145 
      oprot.writeFieldEnd()
14146 
    oprot.writeFieldStop()
14147 
    oprot.writeStructEnd()
14148 
 
3431 rajveer 14149 
  def validate(self):
14150 
    return
14151 
 
14152 
 
304 ashish 14153 
  def __repr__(self):
14154 
    L = ['%s=%r' % (key, value)
14155 
      for key, value in self.__dict__.iteritems()]
14156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14157 
 
14158 
  def __eq__(self, other):
14159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14160 
 
14161 
  def __ne__(self, other):
14162 
    return not (self == other)
14163 
 
3064 chandransh 14164 
class markOrdersAsDelivered_args:
304 ashish 14165 
  """
14166 
  Attributes:
3064 chandransh 14167 
   - providerId
14168 
   - deliveredOrders
304 ashish 14169 
  """
14170 
 
14171 
  thrift_spec = (
14172 
    None, # 0
3064 chandransh 14173 
    (1, TType.I64, 'providerId', None, None, ), # 1
14174 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14175 
  )
14176 
 
3064 chandransh 14177 
  def __init__(self, providerId=None, deliveredOrders=None,):
14178 
    self.providerId = providerId
14179 
    self.deliveredOrders = deliveredOrders
304 ashish 14180 
 
14181 
  def read(self, iprot):
14182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14184 
      return
14185 
    iprot.readStructBegin()
14186 
    while True:
14187 
      (fname, ftype, fid) = iprot.readFieldBegin()
14188 
      if ftype == TType.STOP:
14189 
        break
14190 
      if fid == 1:
14191 
        if ftype == TType.I64:
3064 chandransh 14192 
          self.providerId = iprot.readI64();
304 ashish 14193 
        else:
14194 
          iprot.skip(ftype)
14195 
      elif fid == 2:
3064 chandransh 14196 
        if ftype == TType.MAP:
14197 
          self.deliveredOrders = {}
6031 rajveer 14198 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
14199 
          for _i279 in xrange(_size275):
14200 
            _key280 = iprot.readString();
14201 
            _val281 = iprot.readString();
14202 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 14203 
          iprot.readMapEnd()
304 ashish 14204 
        else:
14205 
          iprot.skip(ftype)
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
3064 chandransh 14215 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14216 
    if self.providerId is not None:
3064 chandransh 14217 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14218 
      oprot.writeI64(self.providerId)
304 ashish 14219 
      oprot.writeFieldEnd()
3431 rajveer 14220 
    if self.deliveredOrders is not None:
3064 chandransh 14221 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14222 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6031 rajveer 14223 
      for kiter282,viter283 in self.deliveredOrders.items():
14224 
        oprot.writeString(kiter282)
14225 
        oprot.writeString(viter283)
3064 chandransh 14226 
      oprot.writeMapEnd()
304 ashish 14227 
      oprot.writeFieldEnd()
14228 
    oprot.writeFieldStop()
14229 
    oprot.writeStructEnd()
14230 
 
3431 rajveer 14231 
  def validate(self):
14232 
    return
14233 
 
14234 
 
304 ashish 14235 
  def __repr__(self):
14236 
    L = ['%s=%r' % (key, value)
14237 
      for key, value in self.__dict__.iteritems()]
14238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14239 
 
14240 
  def __eq__(self, other):
14241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14242 
 
14243 
  def __ne__(self, other):
14244 
    return not (self == other)
14245 
 
3064 chandransh 14246 
class markOrdersAsDelivered_result:
14247 
  """
14248 
  Attributes:
14249 
   - ex
14250 
  """
304 ashish 14251 
 
14252 
  thrift_spec = (
3064 chandransh 14253 
    None, # 0
14254 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14255 
  )
14256 
 
3064 chandransh 14257 
  def __init__(self, ex=None,):
14258 
    self.ex = ex
304 ashish 14259 
 
1596 ankur.sing 14260 
  def read(self, iprot):
14261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14263 
      return
14264 
    iprot.readStructBegin()
14265 
    while True:
14266 
      (fname, ftype, fid) = iprot.readFieldBegin()
14267 
      if ftype == TType.STOP:
14268 
        break
3064 chandransh 14269 
      if fid == 1:
14270 
        if ftype == TType.STRUCT:
14271 
          self.ex = TransactionServiceException()
14272 
          self.ex.read(iprot)
14273 
        else:
14274 
          iprot.skip(ftype)
1596 ankur.sing 14275 
      else:
14276 
        iprot.skip(ftype)
14277 
      iprot.readFieldEnd()
14278 
    iprot.readStructEnd()
14279 
 
14280 
  def write(self, oprot):
14281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14283 
      return
3064 chandransh 14284 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14285 
    if self.ex is not None:
3064 chandransh 14286 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14287 
      self.ex.write(oprot)
14288 
      oprot.writeFieldEnd()
1596 ankur.sing 14289 
    oprot.writeFieldStop()
14290 
    oprot.writeStructEnd()
14291 
 
3431 rajveer 14292 
  def validate(self):
14293 
    return
14294 
 
14295 
 
1596 ankur.sing 14296 
  def __repr__(self):
14297 
    L = ['%s=%r' % (key, value)
14298 
      for key, value in self.__dict__.iteritems()]
14299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14300 
 
14301 
  def __eq__(self, other):
14302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14303 
 
14304 
  def __ne__(self, other):
14305 
    return not (self == other)
14306 
 
4910 phani.kuma 14307 
class markAsRTOrders_args:
1596 ankur.sing 14308 
  """
14309 
  Attributes:
3064 chandransh 14310 
   - providerId
14311 
   - returnedOrders
1596 ankur.sing 14312 
  """
14313 
 
14314 
  thrift_spec = (
3064 chandransh 14315 
    None, # 0
14316 
    (1, TType.I64, 'providerId', None, None, ), # 1
14317 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14318 
  )
14319 
 
3064 chandransh 14320 
  def __init__(self, providerId=None, returnedOrders=None,):
14321 
    self.providerId = providerId
14322 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14323 
 
14324 
  def read(self, iprot):
14325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14327 
      return
14328 
    iprot.readStructBegin()
14329 
    while True:
14330 
      (fname, ftype, fid) = iprot.readFieldBegin()
14331 
      if ftype == TType.STOP:
14332 
        break
3064 chandransh 14333 
      if fid == 1:
1596 ankur.sing 14334 
        if ftype == TType.I64:
3064 chandransh 14335 
          self.providerId = iprot.readI64();
1596 ankur.sing 14336 
        else:
14337 
          iprot.skip(ftype)
3064 chandransh 14338 
      elif fid == 2:
14339 
        if ftype == TType.MAP:
14340 
          self.returnedOrders = {}
6031 rajveer 14341 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
14342 
          for _i288 in xrange(_size284):
14343 
            _key289 = iprot.readString();
14344 
            _val290 = iprot.readString();
14345 
            self.returnedOrders[_key289] = _val290
3064 chandransh 14346 
          iprot.readMapEnd()
14347 
        else:
14348 
          iprot.skip(ftype)
1596 ankur.sing 14349 
      else:
14350 
        iprot.skip(ftype)
14351 
      iprot.readFieldEnd()
14352 
    iprot.readStructEnd()
14353 
 
14354 
  def write(self, oprot):
14355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14357 
      return
4910 phani.kuma 14358 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14359 
    if self.providerId is not None:
3064 chandransh 14360 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14361 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14362 
      oprot.writeFieldEnd()
3431 rajveer 14363 
    if self.returnedOrders is not None:
3064 chandransh 14364 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14365 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6031 rajveer 14366 
      for kiter291,viter292 in self.returnedOrders.items():
14367 
        oprot.writeString(kiter291)
14368 
        oprot.writeString(viter292)
3064 chandransh 14369 
      oprot.writeMapEnd()
14370 
      oprot.writeFieldEnd()
1596 ankur.sing 14371 
    oprot.writeFieldStop()
14372 
    oprot.writeStructEnd()
14373 
 
3431 rajveer 14374 
  def validate(self):
14375 
    return
14376 
 
14377 
 
1596 ankur.sing 14378 
  def __repr__(self):
14379 
    L = ['%s=%r' % (key, value)
14380 
      for key, value in self.__dict__.iteritems()]
14381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14382 
 
14383 
  def __eq__(self, other):
14384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14385 
 
14386 
  def __ne__(self, other):
14387 
    return not (self == other)
14388 
 
4910 phani.kuma 14389 
class markAsRTOrders_result:
3064 chandransh 14390 
  """
14391 
  Attributes:
14392 
   - ex
14393 
  """
1596 ankur.sing 14394 
 
1627 ankur.sing 14395 
  thrift_spec = (
3064 chandransh 14396 
    None, # 0
14397 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14398 
  )
14399 
 
3064 chandransh 14400 
  def __init__(self, ex=None,):
14401 
    self.ex = ex
14402 
 
1627 ankur.sing 14403 
  def read(self, iprot):
14404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14406 
      return
14407 
    iprot.readStructBegin()
14408 
    while True:
14409 
      (fname, ftype, fid) = iprot.readFieldBegin()
14410 
      if ftype == TType.STOP:
14411 
        break
3064 chandransh 14412 
      if fid == 1:
14413 
        if ftype == TType.STRUCT:
14414 
          self.ex = TransactionServiceException()
14415 
          self.ex.read(iprot)
14416 
        else:
14417 
          iprot.skip(ftype)
1627 ankur.sing 14418 
      else:
14419 
        iprot.skip(ftype)
14420 
      iprot.readFieldEnd()
14421 
    iprot.readStructEnd()
14422 
 
14423 
  def write(self, oprot):
14424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14426 
      return
4910 phani.kuma 14427 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14428 
    if self.ex is not None:
3064 chandransh 14429 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14430 
      self.ex.write(oprot)
14431 
      oprot.writeFieldEnd()
1627 ankur.sing 14432 
    oprot.writeFieldStop()
14433 
    oprot.writeStructEnd()
14434 
 
3431 rajveer 14435 
  def validate(self):
14436 
    return
14437 
 
14438 
 
1627 ankur.sing 14439 
  def __repr__(self):
14440 
    L = ['%s=%r' % (key, value)
14441 
      for key, value in self.__dict__.iteritems()]
14442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14443 
 
14444 
  def __eq__(self, other):
14445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14446 
 
14447 
  def __ne__(self, other):
14448 
    return not (self == other)
14449 
 
4910 phani.kuma 14450 
class getRTOrders_args:
14451 
  """
14452 
  Attributes:
14453 
   - providerId
14454 
  """
14455 
 
14456 
  thrift_spec = (
14457 
    None, # 0
14458 
    (1, TType.I64, 'providerId', None, None, ), # 1
14459 
  )
14460 
 
14461 
  def __init__(self, providerId=None,):
14462 
    self.providerId = providerId
14463 
 
14464 
  def read(self, iprot):
14465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14467 
      return
14468 
    iprot.readStructBegin()
14469 
    while True:
14470 
      (fname, ftype, fid) = iprot.readFieldBegin()
14471 
      if ftype == TType.STOP:
14472 
        break
14473 
      if fid == 1:
14474 
        if ftype == TType.I64:
14475 
          self.providerId = iprot.readI64();
14476 
        else:
14477 
          iprot.skip(ftype)
14478 
      else:
14479 
        iprot.skip(ftype)
14480 
      iprot.readFieldEnd()
14481 
    iprot.readStructEnd()
14482 
 
14483 
  def write(self, oprot):
14484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14486 
      return
14487 
    oprot.writeStructBegin('getRTOrders_args')
14488 
    if self.providerId is not None:
14489 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14490 
      oprot.writeI64(self.providerId)
14491 
      oprot.writeFieldEnd()
14492 
    oprot.writeFieldStop()
14493 
    oprot.writeStructEnd()
14494 
 
14495 
  def validate(self):
14496 
    return
14497 
 
14498 
 
14499 
  def __repr__(self):
14500 
    L = ['%s=%r' % (key, value)
14501 
      for key, value in self.__dict__.iteritems()]
14502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14503 
 
14504 
  def __eq__(self, other):
14505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14506 
 
14507 
  def __ne__(self, other):
14508 
    return not (self == other)
14509 
 
14510 
class getRTOrders_result:
14511 
  """
14512 
  Attributes:
14513 
   - success
14514 
  """
14515 
 
14516 
  thrift_spec = (
14517 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14518 
  )
14519 
 
14520 
  def __init__(self, success=None,):
14521 
    self.success = success
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 == 0:
14533 
        if ftype == TType.LIST:
14534 
          self.success = []
6031 rajveer 14535 
          (_etype296, _size293) = iprot.readListBegin()
14536 
          for _i297 in xrange(_size293):
14537 
            _elem298 = Order()
14538 
            _elem298.read(iprot)
14539 
            self.success.append(_elem298)
4910 phani.kuma 14540 
          iprot.readListEnd()
14541 
        else:
14542 
          iprot.skip(ftype)
14543 
      else:
14544 
        iprot.skip(ftype)
14545 
      iprot.readFieldEnd()
14546 
    iprot.readStructEnd()
14547 
 
14548 
  def write(self, oprot):
14549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14551 
      return
14552 
    oprot.writeStructBegin('getRTOrders_result')
14553 
    if self.success is not None:
14554 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14555 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14556 
      for iter299 in self.success:
14557 
        iter299.write(oprot)
4910 phani.kuma 14558 
      oprot.writeListEnd()
14559 
      oprot.writeFieldEnd()
14560 
    oprot.writeFieldStop()
14561 
    oprot.writeStructEnd()
14562 
 
14563 
  def validate(self):
14564 
    return
14565 
 
14566 
 
14567 
  def __repr__(self):
14568 
    L = ['%s=%r' % (key, value)
14569 
      for key, value in self.__dict__.iteritems()]
14570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14571 
 
14572 
  def __eq__(self, other):
14573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14574 
 
14575 
  def __ne__(self, other):
14576 
    return not (self == other)
14577 
 
3064 chandransh 14578 
class updateNonDeliveryReason_args:
1627 ankur.sing 14579 
  """
14580 
  Attributes:
3064 chandransh 14581 
   - providerId
14582 
   - undeliveredOrders
1627 ankur.sing 14583 
  """
14584 
 
14585 
  thrift_spec = (
3064 chandransh 14586 
    None, # 0
14587 
    (1, TType.I64, 'providerId', None, None, ), # 1
14588 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14589 
  )
14590 
 
3064 chandransh 14591 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14592 
    self.providerId = providerId
14593 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14594 
 
14595 
  def read(self, iprot):
14596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14598 
      return
14599 
    iprot.readStructBegin()
14600 
    while True:
14601 
      (fname, ftype, fid) = iprot.readFieldBegin()
14602 
      if ftype == TType.STOP:
14603 
        break
3064 chandransh 14604 
      if fid == 1:
1627 ankur.sing 14605 
        if ftype == TType.I64:
3064 chandransh 14606 
          self.providerId = iprot.readI64();
1627 ankur.sing 14607 
        else:
14608 
          iprot.skip(ftype)
3064 chandransh 14609 
      elif fid == 2:
14610 
        if ftype == TType.MAP:
14611 
          self.undeliveredOrders = {}
6031 rajveer 14612 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
14613 
          for _i304 in xrange(_size300):
14614 
            _key305 = iprot.readString();
14615 
            _val306 = iprot.readString();
14616 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 14617 
          iprot.readMapEnd()
14618 
        else:
14619 
          iprot.skip(ftype)
1627 ankur.sing 14620 
      else:
14621 
        iprot.skip(ftype)
14622 
      iprot.readFieldEnd()
14623 
    iprot.readStructEnd()
14624 
 
14625 
  def write(self, oprot):
14626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14628 
      return
3064 chandransh 14629 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14630 
    if self.providerId is not None:
3064 chandransh 14631 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14632 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14633 
      oprot.writeFieldEnd()
3431 rajveer 14634 
    if self.undeliveredOrders is not None:
3064 chandransh 14635 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14636 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6031 rajveer 14637 
      for kiter307,viter308 in self.undeliveredOrders.items():
14638 
        oprot.writeString(kiter307)
14639 
        oprot.writeString(viter308)
3064 chandransh 14640 
      oprot.writeMapEnd()
14641 
      oprot.writeFieldEnd()
1627 ankur.sing 14642 
    oprot.writeFieldStop()
14643 
    oprot.writeStructEnd()
14644 
 
3431 rajveer 14645 
  def validate(self):
14646 
    return
14647 
 
14648 
 
1627 ankur.sing 14649 
  def __repr__(self):
14650 
    L = ['%s=%r' % (key, value)
14651 
      for key, value in self.__dict__.iteritems()]
14652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14653 
 
14654 
  def __eq__(self, other):
14655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14656 
 
14657 
  def __ne__(self, other):
14658 
    return not (self == other)
14659 
 
3064 chandransh 14660 
class updateNonDeliveryReason_result:
1627 ankur.sing 14661 
  """
14662 
  Attributes:
3064 chandransh 14663 
   - ex
1627 ankur.sing 14664 
  """
14665 
 
14666 
  thrift_spec = (
4910 phani.kuma 14667 
    None, # 0
3064 chandransh 14668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14669 
  )
14670 
 
4910 phani.kuma 14671 
  def __init__(self, ex=None,):
3064 chandransh 14672 
    self.ex = ex
1627 ankur.sing 14673 
 
14674 
  def read(self, iprot):
14675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14677 
      return
14678 
    iprot.readStructBegin()
14679 
    while True:
14680 
      (fname, ftype, fid) = iprot.readFieldBegin()
14681 
      if ftype == TType.STOP:
14682 
        break
4910 phani.kuma 14683 
      if fid == 1:
14684 
        if ftype == TType.STRUCT:
14685 
          self.ex = TransactionServiceException()
14686 
          self.ex.read(iprot)
14687 
        else:
14688 
          iprot.skip(ftype)
14689 
      else:
14690 
        iprot.skip(ftype)
14691 
      iprot.readFieldEnd()
14692 
    iprot.readStructEnd()
14693 
 
14694 
  def write(self, oprot):
14695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14697 
      return
14698 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14699 
    if self.ex is not None:
14700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14701 
      self.ex.write(oprot)
14702 
      oprot.writeFieldEnd()
14703 
    oprot.writeFieldStop()
14704 
    oprot.writeStructEnd()
14705 
 
14706 
  def validate(self):
14707 
    return
14708 
 
14709 
 
14710 
  def __repr__(self):
14711 
    L = ['%s=%r' % (key, value)
14712 
      for key, value in self.__dict__.iteritems()]
14713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14714 
 
14715 
  def __eq__(self, other):
14716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14717 
 
14718 
  def __ne__(self, other):
14719 
    return not (self == other)
14720 
 
14721 
class getNonDeliveredOrdersbyCourier_args:
14722 
  """
14723 
  Attributes:
14724 
   - providerId
14725 
  """
14726 
 
14727 
  thrift_spec = (
14728 
    None, # 0
14729 
    (1, TType.I64, 'providerId', None, None, ), # 1
14730 
  )
14731 
 
14732 
  def __init__(self, providerId=None,):
14733 
    self.providerId = providerId
14734 
 
14735 
  def read(self, iprot):
14736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14738 
      return
14739 
    iprot.readStructBegin()
14740 
    while True:
14741 
      (fname, ftype, fid) = iprot.readFieldBegin()
14742 
      if ftype == TType.STOP:
14743 
        break
14744 
      if fid == 1:
14745 
        if ftype == TType.I64:
14746 
          self.providerId = iprot.readI64();
14747 
        else:
14748 
          iprot.skip(ftype)
14749 
      else:
14750 
        iprot.skip(ftype)
14751 
      iprot.readFieldEnd()
14752 
    iprot.readStructEnd()
14753 
 
14754 
  def write(self, oprot):
14755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14757 
      return
14758 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14759 
    if self.providerId is not None:
14760 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14761 
      oprot.writeI64(self.providerId)
14762 
      oprot.writeFieldEnd()
14763 
    oprot.writeFieldStop()
14764 
    oprot.writeStructEnd()
14765 
 
14766 
  def validate(self):
14767 
    return
14768 
 
14769 
 
14770 
  def __repr__(self):
14771 
    L = ['%s=%r' % (key, value)
14772 
      for key, value in self.__dict__.iteritems()]
14773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14774 
 
14775 
  def __eq__(self, other):
14776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14777 
 
14778 
  def __ne__(self, other):
14779 
    return not (self == other)
14780 
 
14781 
class getNonDeliveredOrdersbyCourier_result:
14782 
  """
14783 
  Attributes:
14784 
   - success
14785 
  """
14786 
 
14787 
  thrift_spec = (
14788 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14789 
  )
14790 
 
14791 
  def __init__(self, success=None,):
14792 
    self.success = success
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
4581 phani.kuma 14803 
      if fid == 0:
14804 
        if ftype == TType.LIST:
14805 
          self.success = []
6031 rajveer 14806 
          (_etype312, _size309) = iprot.readListBegin()
14807 
          for _i313 in xrange(_size309):
14808 
            _elem314 = Order()
14809 
            _elem314.read(iprot)
14810 
            self.success.append(_elem314)
4581 phani.kuma 14811 
          iprot.readListEnd()
14812 
        else:
14813 
          iprot.skip(ftype)
4910 phani.kuma 14814 
      else:
14815 
        iprot.skip(ftype)
14816 
      iprot.readFieldEnd()
14817 
    iprot.readStructEnd()
14818 
 
14819 
  def write(self, oprot):
14820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14822 
      return
14823 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14824 
    if self.success is not None:
14825 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14826 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14827 
      for iter315 in self.success:
14828 
        iter315.write(oprot)
4910 phani.kuma 14829 
      oprot.writeListEnd()
14830 
      oprot.writeFieldEnd()
14831 
    oprot.writeFieldStop()
14832 
    oprot.writeStructEnd()
14833 
 
14834 
  def validate(self):
14835 
    return
14836 
 
14837 
 
14838 
  def __repr__(self):
14839 
    L = ['%s=%r' % (key, value)
14840 
      for key, value in self.__dict__.iteritems()]
14841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14842 
 
14843 
  def __eq__(self, other):
14844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14845 
 
14846 
  def __ne__(self, other):
14847 
    return not (self == other)
14848 
 
14849 
class markOrdersAsLocalConnected_args:
14850 
  """
14851 
  Attributes:
14852 
   - providerId
14853 
   - local_connected_orders
14854 
  """
14855 
 
14856 
  thrift_spec = (
14857 
    None, # 0
14858 
    (1, TType.I64, 'providerId', None, None, ), # 1
14859 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14860 
  )
14861 
 
14862 
  def __init__(self, providerId=None, local_connected_orders=None,):
14863 
    self.providerId = providerId
14864 
    self.local_connected_orders = local_connected_orders
14865 
 
14866 
  def read(self, iprot):
14867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14869 
      return
14870 
    iprot.readStructBegin()
14871 
    while True:
14872 
      (fname, ftype, fid) = iprot.readFieldBegin()
14873 
      if ftype == TType.STOP:
14874 
        break
14875 
      if fid == 1:
14876 
        if ftype == TType.I64:
14877 
          self.providerId = iprot.readI64();
14878 
        else:
14879 
          iprot.skip(ftype)
14880 
      elif fid == 2:
14881 
        if ftype == TType.MAP:
14882 
          self.local_connected_orders = {}
6031 rajveer 14883 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14884 
          for _i320 in xrange(_size316):
14885 
            _key321 = iprot.readString();
14886 
            _val322 = iprot.readString();
14887 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14888 
          iprot.readMapEnd()
14889 
        else:
14890 
          iprot.skip(ftype)
14891 
      else:
14892 
        iprot.skip(ftype)
14893 
      iprot.readFieldEnd()
14894 
    iprot.readStructEnd()
14895 
 
14896 
  def write(self, oprot):
14897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14899 
      return
14900 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14901 
    if self.providerId is not None:
14902 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14903 
      oprot.writeI64(self.providerId)
14904 
      oprot.writeFieldEnd()
14905 
    if self.local_connected_orders is not None:
14906 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14907 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6031 rajveer 14908 
      for kiter323,viter324 in self.local_connected_orders.items():
14909 
        oprot.writeString(kiter323)
14910 
        oprot.writeString(viter324)
4910 phani.kuma 14911 
      oprot.writeMapEnd()
14912 
      oprot.writeFieldEnd()
14913 
    oprot.writeFieldStop()
14914 
    oprot.writeStructEnd()
14915 
 
14916 
  def validate(self):
14917 
    return
14918 
 
14919 
 
14920 
  def __repr__(self):
14921 
    L = ['%s=%r' % (key, value)
14922 
      for key, value in self.__dict__.iteritems()]
14923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14924 
 
14925 
  def __eq__(self, other):
14926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14927 
 
14928 
  def __ne__(self, other):
14929 
    return not (self == other)
14930 
 
14931 
class markOrdersAsLocalConnected_result:
14932 
  """
14933 
  Attributes:
14934 
   - ex
14935 
  """
14936 
 
14937 
  thrift_spec = (
14938 
    None, # 0
14939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14940 
  )
14941 
 
14942 
  def __init__(self, ex=None,):
14943 
    self.ex = ex
14944 
 
14945 
  def read(self, iprot):
14946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14948 
      return
14949 
    iprot.readStructBegin()
14950 
    while True:
14951 
      (fname, ftype, fid) = iprot.readFieldBegin()
14952 
      if ftype == TType.STOP:
14953 
        break
14954 
      if fid == 1:
3064 chandransh 14955 
        if ftype == TType.STRUCT:
14956 
          self.ex = TransactionServiceException()
14957 
          self.ex.read(iprot)
1627 ankur.sing 14958 
        else:
14959 
          iprot.skip(ftype)
14960 
      else:
14961 
        iprot.skip(ftype)
14962 
      iprot.readFieldEnd()
14963 
    iprot.readStructEnd()
14964 
 
14965 
  def write(self, oprot):
14966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14968 
      return
4910 phani.kuma 14969 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14970 
    if self.ex is not None:
14971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14972 
      self.ex.write(oprot)
14973 
      oprot.writeFieldEnd()
14974 
    oprot.writeFieldStop()
14975 
    oprot.writeStructEnd()
14976 
 
14977 
  def validate(self):
14978 
    return
14979 
 
14980 
 
14981 
  def __repr__(self):
14982 
    L = ['%s=%r' % (key, value)
14983 
      for key, value in self.__dict__.iteritems()]
14984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14985 
 
14986 
  def __eq__(self, other):
14987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14988 
 
14989 
  def __ne__(self, other):
14990 
    return not (self == other)
14991 
 
14992 
class getOrdersNotLocalConnected_args:
14993 
  """
14994 
  Attributes:
14995 
   - providerId
14996 
  """
14997 
 
14998 
  thrift_spec = (
14999 
    None, # 0
15000 
    (1, TType.I64, 'providerId', None, None, ), # 1
15001 
  )
15002 
 
15003 
  def __init__(self, providerId=None,):
15004 
    self.providerId = providerId
15005 
 
15006 
  def read(self, iprot):
15007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15009 
      return
15010 
    iprot.readStructBegin()
15011 
    while True:
15012 
      (fname, ftype, fid) = iprot.readFieldBegin()
15013 
      if ftype == TType.STOP:
15014 
        break
15015 
      if fid == 1:
15016 
        if ftype == TType.I64:
15017 
          self.providerId = iprot.readI64();
15018 
        else:
15019 
          iprot.skip(ftype)
15020 
      else:
15021 
        iprot.skip(ftype)
15022 
      iprot.readFieldEnd()
15023 
    iprot.readStructEnd()
15024 
 
15025 
  def write(self, oprot):
15026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15028 
      return
15029 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15030 
    if self.providerId is not None:
15031 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15032 
      oprot.writeI64(self.providerId)
15033 
      oprot.writeFieldEnd()
15034 
    oprot.writeFieldStop()
15035 
    oprot.writeStructEnd()
15036 
 
15037 
  def validate(self):
15038 
    return
15039 
 
15040 
 
15041 
  def __repr__(self):
15042 
    L = ['%s=%r' % (key, value)
15043 
      for key, value in self.__dict__.iteritems()]
15044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15045 
 
15046 
  def __eq__(self, other):
15047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15048 
 
15049 
  def __ne__(self, other):
15050 
    return not (self == other)
15051 
 
15052 
class getOrdersNotLocalConnected_result:
15053 
  """
15054 
  Attributes:
15055 
   - success
15056 
  """
15057 
 
15058 
  thrift_spec = (
15059 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15060 
  )
15061 
 
15062 
  def __init__(self, success=None,):
15063 
    self.success = success
15064 
 
15065 
  def read(self, iprot):
15066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15068 
      return
15069 
    iprot.readStructBegin()
15070 
    while True:
15071 
      (fname, ftype, fid) = iprot.readFieldBegin()
15072 
      if ftype == TType.STOP:
15073 
        break
15074 
      if fid == 0:
15075 
        if ftype == TType.LIST:
15076 
          self.success = []
6031 rajveer 15077 
          (_etype328, _size325) = iprot.readListBegin()
15078 
          for _i329 in xrange(_size325):
15079 
            _elem330 = Order()
15080 
            _elem330.read(iprot)
15081 
            self.success.append(_elem330)
4910 phani.kuma 15082 
          iprot.readListEnd()
15083 
        else:
15084 
          iprot.skip(ftype)
15085 
      else:
15086 
        iprot.skip(ftype)
15087 
      iprot.readFieldEnd()
15088 
    iprot.readStructEnd()
15089 
 
15090 
  def write(self, oprot):
15091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15093 
      return
15094 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15095 
    if self.success is not None:
15096 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15097 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15098 
      for iter331 in self.success:
15099 
        iter331.write(oprot)
4581 phani.kuma 15100 
      oprot.writeListEnd()
15101 
      oprot.writeFieldEnd()
4910 phani.kuma 15102 
    oprot.writeFieldStop()
15103 
    oprot.writeStructEnd()
15104 
 
15105 
  def validate(self):
15106 
    return
15107 
 
15108 
 
15109 
  def __repr__(self):
15110 
    L = ['%s=%r' % (key, value)
15111 
      for key, value in self.__dict__.iteritems()]
15112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15113 
 
15114 
  def __eq__(self, other):
15115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15116 
 
15117 
  def __ne__(self, other):
15118 
    return not (self == other)
15119 
 
15120 
class markOrdersAsDestinationCityReached_args:
15121 
  """
15122 
  Attributes:
15123 
   - providerId
15124 
   - destination_city_reached_orders
15125 
  """
15126 
 
15127 
  thrift_spec = (
15128 
    None, # 0
15129 
    (1, TType.I64, 'providerId', None, None, ), # 1
15130 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15131 
  )
15132 
 
15133 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15134 
    self.providerId = providerId
15135 
    self.destination_city_reached_orders = destination_city_reached_orders
15136 
 
15137 
  def read(self, iprot):
15138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15140 
      return
15141 
    iprot.readStructBegin()
15142 
    while True:
15143 
      (fname, ftype, fid) = iprot.readFieldBegin()
15144 
      if ftype == TType.STOP:
15145 
        break
15146 
      if fid == 1:
15147 
        if ftype == TType.I64:
15148 
          self.providerId = iprot.readI64();
15149 
        else:
15150 
          iprot.skip(ftype)
15151 
      elif fid == 2:
15152 
        if ftype == TType.MAP:
15153 
          self.destination_city_reached_orders = {}
6031 rajveer 15154 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
15155 
          for _i336 in xrange(_size332):
15156 
            _key337 = iprot.readString();
15157 
            _val338 = iprot.readString();
15158 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 15159 
          iprot.readMapEnd()
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('markOrdersAsDestinationCityReached_args')
15172 
    if self.providerId is not None:
15173 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15174 
      oprot.writeI64(self.providerId)
15175 
      oprot.writeFieldEnd()
15176 
    if self.destination_city_reached_orders is not None:
15177 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15178 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6031 rajveer 15179 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
15180 
        oprot.writeString(kiter339)
15181 
        oprot.writeString(viter340)
4910 phani.kuma 15182 
      oprot.writeMapEnd()
15183 
      oprot.writeFieldEnd()
15184 
    oprot.writeFieldStop()
15185 
    oprot.writeStructEnd()
15186 
 
15187 
  def validate(self):
15188 
    return
15189 
 
15190 
 
15191 
  def __repr__(self):
15192 
    L = ['%s=%r' % (key, value)
15193 
      for key, value in self.__dict__.iteritems()]
15194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15195 
 
15196 
  def __eq__(self, other):
15197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15198 
 
15199 
  def __ne__(self, other):
15200 
    return not (self == other)
15201 
 
15202 
class markOrdersAsDestinationCityReached_result:
15203 
  """
15204 
  Attributes:
15205 
   - ex
15206 
  """
15207 
 
15208 
  thrift_spec = (
15209 
    None, # 0
15210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15211 
  )
15212 
 
15213 
  def __init__(self, ex=None,):
15214 
    self.ex = ex
15215 
 
15216 
  def read(self, iprot):
15217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15219 
      return
15220 
    iprot.readStructBegin()
15221 
    while True:
15222 
      (fname, ftype, fid) = iprot.readFieldBegin()
15223 
      if ftype == TType.STOP:
15224 
        break
15225 
      if fid == 1:
15226 
        if ftype == TType.STRUCT:
15227 
          self.ex = TransactionServiceException()
15228 
          self.ex.read(iprot)
15229 
        else:
15230 
          iprot.skip(ftype)
15231 
      else:
15232 
        iprot.skip(ftype)
15233 
      iprot.readFieldEnd()
15234 
    iprot.readStructEnd()
15235 
 
15236 
  def write(self, oprot):
15237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15239 
      return
15240 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15241 
    if self.ex is not None:
3064 chandransh 15242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15243 
      self.ex.write(oprot)
1627 ankur.sing 15244 
      oprot.writeFieldEnd()
15245 
    oprot.writeFieldStop()
15246 
    oprot.writeStructEnd()
15247 
 
3431 rajveer 15248 
  def validate(self):
15249 
    return
15250 
 
15251 
 
1627 ankur.sing 15252 
  def __repr__(self):
15253 
    L = ['%s=%r' % (key, value)
15254 
      for key, value in self.__dict__.iteritems()]
15255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15256 
 
15257 
  def __eq__(self, other):
15258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15259 
 
15260 
  def __ne__(self, other):
15261 
    return not (self == other)
15262 
 
4910 phani.kuma 15263 
class markOrdersAsFirstDeliveryAttempted_args:
15264 
  """
15265 
  Attributes:
15266 
   - providerId
15267 
   - first_atdl_orders
15268 
  """
15269 
 
15270 
  thrift_spec = (
15271 
    None, # 0
15272 
    (1, TType.I64, 'providerId', None, None, ), # 1
15273 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15274 
  )
15275 
 
15276 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15277 
    self.providerId = providerId
15278 
    self.first_atdl_orders = first_atdl_orders
15279 
 
15280 
  def read(self, iprot):
15281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15283 
      return
15284 
    iprot.readStructBegin()
15285 
    while True:
15286 
      (fname, ftype, fid) = iprot.readFieldBegin()
15287 
      if ftype == TType.STOP:
15288 
        break
15289 
      if fid == 1:
15290 
        if ftype == TType.I64:
15291 
          self.providerId = iprot.readI64();
15292 
        else:
15293 
          iprot.skip(ftype)
15294 
      elif fid == 2:
15295 
        if ftype == TType.MAP:
15296 
          self.first_atdl_orders = {}
6031 rajveer 15297 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
15298 
          for _i345 in xrange(_size341):
15299 
            _key346 = iprot.readString();
15300 
            _val347 = iprot.readString();
15301 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 15302 
          iprot.readMapEnd()
15303 
        else:
15304 
          iprot.skip(ftype)
15305 
      else:
15306 
        iprot.skip(ftype)
15307 
      iprot.readFieldEnd()
15308 
    iprot.readStructEnd()
15309 
 
15310 
  def write(self, oprot):
15311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15313 
      return
15314 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15315 
    if self.providerId is not None:
15316 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15317 
      oprot.writeI64(self.providerId)
15318 
      oprot.writeFieldEnd()
15319 
    if self.first_atdl_orders is not None:
15320 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15321 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6031 rajveer 15322 
      for kiter348,viter349 in self.first_atdl_orders.items():
15323 
        oprot.writeString(kiter348)
15324 
        oprot.writeString(viter349)
4910 phani.kuma 15325 
      oprot.writeMapEnd()
15326 
      oprot.writeFieldEnd()
15327 
    oprot.writeFieldStop()
15328 
    oprot.writeStructEnd()
15329 
 
15330 
  def validate(self):
15331 
    return
15332 
 
15333 
 
15334 
  def __repr__(self):
15335 
    L = ['%s=%r' % (key, value)
15336 
      for key, value in self.__dict__.iteritems()]
15337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15338 
 
15339 
  def __eq__(self, other):
15340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15341 
 
15342 
  def __ne__(self, other):
15343 
    return not (self == other)
15344 
 
15345 
class markOrdersAsFirstDeliveryAttempted_result:
15346 
  """
15347 
  Attributes:
15348 
   - ex
15349 
  """
15350 
 
15351 
  thrift_spec = (
15352 
    None, # 0
15353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15354 
  )
15355 
 
15356 
  def __init__(self, ex=None,):
15357 
    self.ex = ex
15358 
 
15359 
  def read(self, iprot):
15360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15362 
      return
15363 
    iprot.readStructBegin()
15364 
    while True:
15365 
      (fname, ftype, fid) = iprot.readFieldBegin()
15366 
      if ftype == TType.STOP:
15367 
        break
15368 
      if fid == 1:
15369 
        if ftype == TType.STRUCT:
15370 
          self.ex = TransactionServiceException()
15371 
          self.ex.read(iprot)
15372 
        else:
15373 
          iprot.skip(ftype)
15374 
      else:
15375 
        iprot.skip(ftype)
15376 
      iprot.readFieldEnd()
15377 
    iprot.readStructEnd()
15378 
 
15379 
  def write(self, oprot):
15380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15382 
      return
15383 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15384 
    if self.ex is not None:
15385 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15386 
      self.ex.write(oprot)
15387 
      oprot.writeFieldEnd()
15388 
    oprot.writeFieldStop()
15389 
    oprot.writeStructEnd()
15390 
 
15391 
  def validate(self):
15392 
    return
15393 
 
15394 
 
15395 
  def __repr__(self):
15396 
    L = ['%s=%r' % (key, value)
15397 
      for key, value in self.__dict__.iteritems()]
15398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15399 
 
15400 
  def __eq__(self, other):
15401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15402 
 
15403 
  def __ne__(self, other):
15404 
    return not (self == other)
15405 
 
3064 chandransh 15406 
class getUndeliveredOrders_args:
1886 ankur.sing 15407 
  """
15408 
  Attributes:
3064 chandransh 15409 
   - providerId
15410 
   - warehouseId
1886 ankur.sing 15411 
  """
1627 ankur.sing 15412 
 
1886 ankur.sing 15413 
  thrift_spec = (
15414 
    None, # 0
3064 chandransh 15415 
    (1, TType.I64, 'providerId', None, None, ), # 1
15416 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15417 
  )
15418 
 
3064 chandransh 15419 
  def __init__(self, providerId=None, warehouseId=None,):
15420 
    self.providerId = providerId
15421 
    self.warehouseId = warehouseId
1886 ankur.sing 15422 
 
15423 
  def read(self, iprot):
15424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15426 
      return
15427 
    iprot.readStructBegin()
15428 
    while True:
15429 
      (fname, ftype, fid) = iprot.readFieldBegin()
15430 
      if ftype == TType.STOP:
15431 
        break
15432 
      if fid == 1:
15433 
        if ftype == TType.I64:
3064 chandransh 15434 
          self.providerId = iprot.readI64();
1886 ankur.sing 15435 
        else:
15436 
          iprot.skip(ftype)
3064 chandransh 15437 
      elif fid == 2:
15438 
        if ftype == TType.I64:
15439 
          self.warehouseId = iprot.readI64();
15440 
        else:
15441 
          iprot.skip(ftype)
1886 ankur.sing 15442 
      else:
15443 
        iprot.skip(ftype)
15444 
      iprot.readFieldEnd()
15445 
    iprot.readStructEnd()
15446 
 
15447 
  def write(self, oprot):
15448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15450 
      return
3064 chandransh 15451 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15452 
    if self.providerId is not None:
3064 chandransh 15453 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15454 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15455 
      oprot.writeFieldEnd()
3431 rajveer 15456 
    if self.warehouseId is not None:
3064 chandransh 15457 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15458 
      oprot.writeI64(self.warehouseId)
15459 
      oprot.writeFieldEnd()
1886 ankur.sing 15460 
    oprot.writeFieldStop()
15461 
    oprot.writeStructEnd()
15462 
 
3431 rajveer 15463 
  def validate(self):
15464 
    return
15465 
 
15466 
 
1886 ankur.sing 15467 
  def __repr__(self):
15468 
    L = ['%s=%r' % (key, value)
15469 
      for key, value in self.__dict__.iteritems()]
15470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15471 
 
15472 
  def __eq__(self, other):
15473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15474 
 
15475 
  def __ne__(self, other):
15476 
    return not (self == other)
15477 
 
3064 chandransh 15478 
class getUndeliveredOrders_result:
1886 ankur.sing 15479 
  """
15480 
  Attributes:
15481 
   - success
15482 
  """
15483 
 
15484 
  thrift_spec = (
15485 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15486 
  )
15487 
 
15488 
  def __init__(self, success=None,):
15489 
    self.success = success
15490 
 
15491 
  def read(self, iprot):
15492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15494 
      return
15495 
    iprot.readStructBegin()
15496 
    while True:
15497 
      (fname, ftype, fid) = iprot.readFieldBegin()
15498 
      if ftype == TType.STOP:
15499 
        break
15500 
      if fid == 0:
15501 
        if ftype == TType.LIST:
15502 
          self.success = []
6031 rajveer 15503 
          (_etype353, _size350) = iprot.readListBegin()
15504 
          for _i354 in xrange(_size350):
15505 
            _elem355 = Order()
15506 
            _elem355.read(iprot)
15507 
            self.success.append(_elem355)
1886 ankur.sing 15508 
          iprot.readListEnd()
15509 
        else:
15510 
          iprot.skip(ftype)
15511 
      else:
15512 
        iprot.skip(ftype)
15513 
      iprot.readFieldEnd()
15514 
    iprot.readStructEnd()
15515 
 
15516 
  def write(self, oprot):
15517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15519 
      return
3064 chandransh 15520 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15521 
    if self.success is not None:
1886 ankur.sing 15522 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15523 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15524 
      for iter356 in self.success:
15525 
        iter356.write(oprot)
1886 ankur.sing 15526 
      oprot.writeListEnd()
15527 
      oprot.writeFieldEnd()
15528 
    oprot.writeFieldStop()
15529 
    oprot.writeStructEnd()
15530 
 
3431 rajveer 15531 
  def validate(self):
15532 
    return
15533 
 
15534 
 
1886 ankur.sing 15535 
  def __repr__(self):
15536 
    L = ['%s=%r' % (key, value)
15537 
      for key, value in self.__dict__.iteritems()]
15538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15539 
 
15540 
  def __eq__(self, other):
15541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15542 
 
15543 
  def __ne__(self, other):
15544 
    return not (self == other)
15545 
 
4783 phani.kuma 15546 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15547 
 
15548 
  thrift_spec = (
15549 
  )
15550 
 
15551 
  def read(self, iprot):
15552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15554 
      return
15555 
    iprot.readStructBegin()
15556 
    while True:
15557 
      (fname, ftype, fid) = iprot.readFieldBegin()
15558 
      if ftype == TType.STOP:
15559 
        break
15560 
      else:
15561 
        iprot.skip(ftype)
15562 
      iprot.readFieldEnd()
15563 
    iprot.readStructEnd()
15564 
 
15565 
  def write(self, oprot):
15566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15568 
      return
15569 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15570 
    oprot.writeFieldStop()
15571 
    oprot.writeStructEnd()
15572 
 
15573 
  def validate(self):
15574 
    return
15575 
 
15576 
 
15577 
  def __repr__(self):
15578 
    L = ['%s=%r' % (key, value)
15579 
      for key, value in self.__dict__.iteritems()]
15580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15581 
 
15582 
  def __eq__(self, other):
15583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15584 
 
15585 
  def __ne__(self, other):
15586 
    return not (self == other)
15587 
 
15588 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15589 
  """
15590 
  Attributes:
15591 
   - success
15592 
  """
15593 
 
15594 
  thrift_spec = (
15595 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15596 
  )
15597 
 
15598 
  def __init__(self, success=None,):
15599 
    self.success = success
15600 
 
15601 
  def read(self, iprot):
15602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15604 
      return
15605 
    iprot.readStructBegin()
15606 
    while True:
15607 
      (fname, ftype, fid) = iprot.readFieldBegin()
15608 
      if ftype == TType.STOP:
15609 
        break
15610 
      if fid == 0:
15611 
        if ftype == TType.LIST:
15612 
          self.success = []
6031 rajveer 15613 
          (_etype360, _size357) = iprot.readListBegin()
15614 
          for _i361 in xrange(_size357):
15615 
            _elem362 = Order()
15616 
            _elem362.read(iprot)
15617 
            self.success.append(_elem362)
4783 phani.kuma 15618 
          iprot.readListEnd()
15619 
        else:
15620 
          iprot.skip(ftype)
15621 
      else:
15622 
        iprot.skip(ftype)
15623 
      iprot.readFieldEnd()
15624 
    iprot.readStructEnd()
15625 
 
15626 
  def write(self, oprot):
15627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15629 
      return
15630 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15631 
    if self.success is not None:
15632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15634 
      for iter363 in self.success:
15635 
        iter363.write(oprot)
4783 phani.kuma 15636 
      oprot.writeListEnd()
15637 
      oprot.writeFieldEnd()
15638 
    oprot.writeFieldStop()
15639 
    oprot.writeStructEnd()
15640 
 
15641 
  def validate(self):
15642 
    return
15643 
 
15644 
 
15645 
  def __repr__(self):
15646 
    L = ['%s=%r' % (key, value)
15647 
      for key, value in self.__dict__.iteritems()]
15648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15649 
 
15650 
  def __eq__(self, other):
15651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15652 
 
15653 
  def __ne__(self, other):
15654 
    return not (self == other)
15655 
 
2536 chandransh 15656 
class toggleDOAFlag_args:
15657 
  """
15658 
  Attributes:
15659 
   - orderId
15660 
  """
1886 ankur.sing 15661 
 
2536 chandransh 15662 
  thrift_spec = (
15663 
    None, # 0
15664 
    (1, TType.I64, 'orderId', None, None, ), # 1
15665 
  )
15666 
 
15667 
  def __init__(self, orderId=None,):
15668 
    self.orderId = orderId
15669 
 
15670 
  def read(self, iprot):
15671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15673 
      return
15674 
    iprot.readStructBegin()
15675 
    while True:
15676 
      (fname, ftype, fid) = iprot.readFieldBegin()
15677 
      if ftype == TType.STOP:
15678 
        break
15679 
      if fid == 1:
15680 
        if ftype == TType.I64:
15681 
          self.orderId = iprot.readI64();
15682 
        else:
15683 
          iprot.skip(ftype)
15684 
      else:
15685 
        iprot.skip(ftype)
15686 
      iprot.readFieldEnd()
15687 
    iprot.readStructEnd()
15688 
 
15689 
  def write(self, oprot):
15690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15692 
      return
15693 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15694 
    if self.orderId is not None:
2536 chandransh 15695 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15696 
      oprot.writeI64(self.orderId)
15697 
      oprot.writeFieldEnd()
15698 
    oprot.writeFieldStop()
15699 
    oprot.writeStructEnd()
15700 
 
3431 rajveer 15701 
  def validate(self):
15702 
    return
15703 
 
15704 
 
2536 chandransh 15705 
  def __repr__(self):
15706 
    L = ['%s=%r' % (key, value)
15707 
      for key, value in self.__dict__.iteritems()]
15708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15709 
 
15710 
  def __eq__(self, other):
15711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15712 
 
15713 
  def __ne__(self, other):
15714 
    return not (self == other)
15715 
 
15716 
class toggleDOAFlag_result:
15717 
  """
15718 
  Attributes:
15719 
   - success
15720 
   - ex
15721 
  """
15722 
 
15723 
  thrift_spec = (
15724 
    (0, TType.BOOL, 'success', None, None, ), # 0
15725 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15726 
  )
15727 
 
15728 
  def __init__(self, success=None, ex=None,):
15729 
    self.success = success
15730 
    self.ex = ex
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 == 0:
15742 
        if ftype == TType.BOOL:
15743 
          self.success = iprot.readBool();
15744 
        else:
15745 
          iprot.skip(ftype)
15746 
      elif fid == 1:
15747 
        if ftype == TType.STRUCT:
15748 
          self.ex = TransactionServiceException()
15749 
          self.ex.read(iprot)
15750 
        else:
15751 
          iprot.skip(ftype)
15752 
      else:
15753 
        iprot.skip(ftype)
15754 
      iprot.readFieldEnd()
15755 
    iprot.readStructEnd()
15756 
 
15757 
  def write(self, oprot):
15758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15760 
      return
15761 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15762 
    if self.success is not None:
2536 chandransh 15763 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15764 
      oprot.writeBool(self.success)
15765 
      oprot.writeFieldEnd()
3431 rajveer 15766 
    if self.ex is not None:
2536 chandransh 15767 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15768 
      self.ex.write(oprot)
15769 
      oprot.writeFieldEnd()
15770 
    oprot.writeFieldStop()
15771 
    oprot.writeStructEnd()
15772 
 
3431 rajveer 15773 
  def validate(self):
15774 
    return
15775 
 
15776 
 
2536 chandransh 15777 
  def __repr__(self):
15778 
    L = ['%s=%r' % (key, value)
15779 
      for key, value in self.__dict__.iteritems()]
15780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15781 
 
15782 
  def __eq__(self, other):
15783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15784 
 
15785 
  def __ne__(self, other):
15786 
    return not (self == other)
15787 
 
4712 rajveer 15788 
class markOrderAsDelivered_args:
15789 
  """
15790 
  Attributes:
15791 
   - orderId
15792 
   - deliveryTimestamp
15793 
   - receiver
15794 
  """
15795 
 
15796 
  thrift_spec = None
15797 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15798 
    self.orderId = orderId
15799 
    self.deliveryTimestamp = deliveryTimestamp
15800 
    self.receiver = receiver
15801 
 
15802 
  def read(self, iprot):
15803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15805 
      return
15806 
    iprot.readStructBegin()
15807 
    while True:
15808 
      (fname, ftype, fid) = iprot.readFieldBegin()
15809 
      if ftype == TType.STOP:
15810 
        break
15811 
      if fid == 1:
15812 
        if ftype == TType.I64:
15813 
          self.orderId = iprot.readI64();
15814 
        else:
15815 
          iprot.skip(ftype)
15816 
      elif fid == 2:
15817 
        if ftype == TType.I64:
15818 
          self.deliveryTimestamp = iprot.readI64();
15819 
        else:
15820 
          iprot.skip(ftype)
15821 
      elif fid == -1:
15822 
        if ftype == TType.STRING:
15823 
          self.receiver = iprot.readString();
15824 
        else:
15825 
          iprot.skip(ftype)
15826 
      else:
15827 
        iprot.skip(ftype)
15828 
      iprot.readFieldEnd()
15829 
    iprot.readStructEnd()
15830 
 
15831 
  def write(self, oprot):
15832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15834 
      return
15835 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15836 
    if self.receiver is not None:
15837 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15838 
      oprot.writeString(self.receiver)
15839 
      oprot.writeFieldEnd()
15840 
    if self.orderId is not None:
15841 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15842 
      oprot.writeI64(self.orderId)
15843 
      oprot.writeFieldEnd()
15844 
    if self.deliveryTimestamp is not None:
15845 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15846 
      oprot.writeI64(self.deliveryTimestamp)
15847 
      oprot.writeFieldEnd()
15848 
    oprot.writeFieldStop()
15849 
    oprot.writeStructEnd()
15850 
 
15851 
  def validate(self):
15852 
    return
15853 
 
15854 
 
15855 
  def __repr__(self):
15856 
    L = ['%s=%r' % (key, value)
15857 
      for key, value in self.__dict__.iteritems()]
15858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15859 
 
15860 
  def __eq__(self, other):
15861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15862 
 
15863 
  def __ne__(self, other):
15864 
    return not (self == other)
15865 
 
15866 
class markOrderAsDelivered_result:
15867 
  """
15868 
  Attributes:
15869 
   - ex
15870 
  """
15871 
 
15872 
  thrift_spec = (
15873 
    None, # 0
15874 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15875 
  )
15876 
 
15877 
  def __init__(self, ex=None,):
15878 
    self.ex = ex
15879 
 
15880 
  def read(self, iprot):
15881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15883 
      return
15884 
    iprot.readStructBegin()
15885 
    while True:
15886 
      (fname, ftype, fid) = iprot.readFieldBegin()
15887 
      if ftype == TType.STOP:
15888 
        break
15889 
      if fid == 1:
15890 
        if ftype == TType.STRUCT:
15891 
          self.ex = TransactionServiceException()
15892 
          self.ex.read(iprot)
15893 
        else:
15894 
          iprot.skip(ftype)
15895 
      else:
15896 
        iprot.skip(ftype)
15897 
      iprot.readFieldEnd()
15898 
    iprot.readStructEnd()
15899 
 
15900 
  def write(self, oprot):
15901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15903 
      return
15904 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15905 
    if self.ex is not None:
15906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15907 
      self.ex.write(oprot)
15908 
      oprot.writeFieldEnd()
15909 
    oprot.writeFieldStop()
15910 
    oprot.writeStructEnd()
15911 
 
15912 
  def validate(self):
15913 
    return
15914 
 
15915 
 
15916 
  def __repr__(self):
15917 
    L = ['%s=%r' % (key, value)
15918 
      for key, value in self.__dict__.iteritems()]
15919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15920 
 
15921 
  def __eq__(self, other):
15922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15923 
 
15924 
  def __ne__(self, other):
15925 
    return not (self == other)
15926 
 
5553 rajveer 15927 
class markOrderAsReceivedAtStore_args:
15928 
  """
15929 
  Attributes:
15930 
   - orderId
15931 
   - deliveryTimestamp
15932 
  """
15933 
 
15934 
  thrift_spec = (
15935 
    None, # 0
15936 
    (1, TType.I64, 'orderId', None, None, ), # 1
15937 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15938 
  )
15939 
 
15940 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15941 
    self.orderId = orderId
15942 
    self.deliveryTimestamp = deliveryTimestamp
15943 
 
15944 
  def read(self, iprot):
15945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15947 
      return
15948 
    iprot.readStructBegin()
15949 
    while True:
15950 
      (fname, ftype, fid) = iprot.readFieldBegin()
15951 
      if ftype == TType.STOP:
15952 
        break
15953 
      if fid == 1:
15954 
        if ftype == TType.I64:
15955 
          self.orderId = iprot.readI64();
15956 
        else:
15957 
          iprot.skip(ftype)
15958 
      elif fid == 2:
15959 
        if ftype == TType.I64:
15960 
          self.deliveryTimestamp = iprot.readI64();
15961 
        else:
15962 
          iprot.skip(ftype)
15963 
      else:
15964 
        iprot.skip(ftype)
15965 
      iprot.readFieldEnd()
15966 
    iprot.readStructEnd()
15967 
 
15968 
  def write(self, oprot):
15969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15971 
      return
15972 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15973 
    if self.orderId is not None:
15974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15975 
      oprot.writeI64(self.orderId)
15976 
      oprot.writeFieldEnd()
15977 
    if self.deliveryTimestamp is not None:
15978 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15979 
      oprot.writeI64(self.deliveryTimestamp)
15980 
      oprot.writeFieldEnd()
15981 
    oprot.writeFieldStop()
15982 
    oprot.writeStructEnd()
15983 
 
15984 
  def validate(self):
15985 
    return
15986 
 
15987 
 
15988 
  def __repr__(self):
15989 
    L = ['%s=%r' % (key, value)
15990 
      for key, value in self.__dict__.iteritems()]
15991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15992 
 
15993 
  def __eq__(self, other):
15994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15995 
 
15996 
  def __ne__(self, other):
15997 
    return not (self == other)
15998 
 
15999 
class markOrderAsReceivedAtStore_result:
16000 
  """
16001 
  Attributes:
16002 
   - ex
16003 
  """
16004 
 
16005 
  thrift_spec = (
16006 
    None, # 0
16007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16008 
  )
16009 
 
16010 
  def __init__(self, ex=None,):
16011 
    self.ex = ex
16012 
 
16013 
  def read(self, iprot):
16014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16016 
      return
16017 
    iprot.readStructBegin()
16018 
    while True:
16019 
      (fname, ftype, fid) = iprot.readFieldBegin()
16020 
      if ftype == TType.STOP:
16021 
        break
16022 
      if fid == 1:
16023 
        if ftype == TType.STRUCT:
16024 
          self.ex = TransactionServiceException()
16025 
          self.ex.read(iprot)
16026 
        else:
16027 
          iprot.skip(ftype)
16028 
      else:
16029 
        iprot.skip(ftype)
16030 
      iprot.readFieldEnd()
16031 
    iprot.readStructEnd()
16032 
 
16033 
  def write(self, oprot):
16034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16036 
      return
16037 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16038 
    if self.ex is not None:
16039 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16040 
      self.ex.write(oprot)
16041 
      oprot.writeFieldEnd()
16042 
    oprot.writeFieldStop()
16043 
    oprot.writeStructEnd()
16044 
 
16045 
  def validate(self):
16046 
    return
16047 
 
16048 
 
16049 
  def __repr__(self):
16050 
    L = ['%s=%r' % (key, value)
16051 
      for key, value in self.__dict__.iteritems()]
16052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16053 
 
16054 
  def __eq__(self, other):
16055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16056 
 
16057 
  def __ne__(self, other):
16058 
    return not (self == other)
16059 
 
4454 rajveer 16060 
class markOrderDoaRequestReceived_args:
16061 
  """
16062 
  Attributes:
16063 
   - orderId
16064 
  """
16065 
 
16066 
  thrift_spec = (
16067 
    None, # 0
16068 
    (1, TType.I64, 'orderId', None, None, ), # 1
16069 
  )
16070 
 
16071 
  def __init__(self, orderId=None,):
16072 
    self.orderId = orderId
16073 
 
16074 
  def read(self, iprot):
16075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16077 
      return
16078 
    iprot.readStructBegin()
16079 
    while True:
16080 
      (fname, ftype, fid) = iprot.readFieldBegin()
16081 
      if ftype == TType.STOP:
16082 
        break
16083 
      if fid == 1:
16084 
        if ftype == TType.I64:
16085 
          self.orderId = iprot.readI64();
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('markOrderDoaRequestReceived_args')
16098 
    if self.orderId is not None:
16099 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16100 
      oprot.writeI64(self.orderId)
16101 
      oprot.writeFieldEnd()
16102 
    oprot.writeFieldStop()
16103 
    oprot.writeStructEnd()
16104 
 
16105 
  def validate(self):
16106 
    return
16107 
 
16108 
 
16109 
  def __repr__(self):
16110 
    L = ['%s=%r' % (key, value)
16111 
      for key, value in self.__dict__.iteritems()]
16112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16113 
 
16114 
  def __eq__(self, other):
16115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16116 
 
16117 
  def __ne__(self, other):
16118 
    return not (self == other)
16119 
 
16120 
class markOrderDoaRequestReceived_result:
16121 
  """
16122 
  Attributes:
16123 
   - success
16124 
   - ex
16125 
  """
16126 
 
16127 
  thrift_spec = (
16128 
    (0, TType.BOOL, 'success', None, None, ), # 0
16129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16130 
  )
16131 
 
16132 
  def __init__(self, success=None, ex=None,):
16133 
    self.success = success
16134 
    self.ex = ex
16135 
 
16136 
  def read(self, iprot):
16137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16139 
      return
16140 
    iprot.readStructBegin()
16141 
    while True:
16142 
      (fname, ftype, fid) = iprot.readFieldBegin()
16143 
      if ftype == TType.STOP:
16144 
        break
16145 
      if fid == 0:
16146 
        if ftype == TType.BOOL:
16147 
          self.success = iprot.readBool();
16148 
        else:
16149 
          iprot.skip(ftype)
16150 
      elif fid == 1:
16151 
        if ftype == TType.STRUCT:
16152 
          self.ex = TransactionServiceException()
16153 
          self.ex.read(iprot)
16154 
        else:
16155 
          iprot.skip(ftype)
16156 
      else:
16157 
        iprot.skip(ftype)
16158 
      iprot.readFieldEnd()
16159 
    iprot.readStructEnd()
16160 
 
16161 
  def write(self, oprot):
16162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16164 
      return
16165 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16166 
    if self.success is not None:
16167 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16168 
      oprot.writeBool(self.success)
16169 
      oprot.writeFieldEnd()
16170 
    if self.ex is not None:
16171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16172 
      self.ex.write(oprot)
16173 
      oprot.writeFieldEnd()
16174 
    oprot.writeFieldStop()
16175 
    oprot.writeStructEnd()
16176 
 
16177 
  def validate(self):
16178 
    return
16179 
 
16180 
 
16181 
  def __repr__(self):
16182 
    L = ['%s=%r' % (key, value)
16183 
      for key, value in self.__dict__.iteritems()]
16184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16185 
 
16186 
  def __eq__(self, other):
16187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16188 
 
16189 
  def __ne__(self, other):
16190 
    return not (self == other)
16191 
 
16192 
class markOrderDoaRequestAuthorized_args:
16193 
  """
16194 
  Attributes:
16195 
   - orderId
16196 
   - isAuthorized
16197 
  """
16198 
 
16199 
  thrift_spec = (
16200 
    None, # 0
16201 
    (1, TType.I64, 'orderId', None, None, ), # 1
16202 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16203 
  )
16204 
 
16205 
  def __init__(self, orderId=None, isAuthorized=None,):
16206 
    self.orderId = orderId
16207 
    self.isAuthorized = isAuthorized
16208 
 
16209 
  def read(self, iprot):
16210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16212 
      return
16213 
    iprot.readStructBegin()
16214 
    while True:
16215 
      (fname, ftype, fid) = iprot.readFieldBegin()
16216 
      if ftype == TType.STOP:
16217 
        break
16218 
      if fid == 1:
16219 
        if ftype == TType.I64:
16220 
          self.orderId = iprot.readI64();
16221 
        else:
16222 
          iprot.skip(ftype)
16223 
      elif fid == 2:
16224 
        if ftype == TType.BOOL:
16225 
          self.isAuthorized = iprot.readBool();
16226 
        else:
16227 
          iprot.skip(ftype)
16228 
      else:
16229 
        iprot.skip(ftype)
16230 
      iprot.readFieldEnd()
16231 
    iprot.readStructEnd()
16232 
 
16233 
  def write(self, oprot):
16234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16236 
      return
16237 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16238 
    if self.orderId is not None:
16239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16240 
      oprot.writeI64(self.orderId)
16241 
      oprot.writeFieldEnd()
16242 
    if self.isAuthorized is not None:
16243 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16244 
      oprot.writeBool(self.isAuthorized)
16245 
      oprot.writeFieldEnd()
16246 
    oprot.writeFieldStop()
16247 
    oprot.writeStructEnd()
16248 
 
16249 
  def validate(self):
16250 
    return
16251 
 
16252 
 
16253 
  def __repr__(self):
16254 
    L = ['%s=%r' % (key, value)
16255 
      for key, value in self.__dict__.iteritems()]
16256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16257 
 
16258 
  def __eq__(self, other):
16259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16260 
 
16261 
  def __ne__(self, other):
16262 
    return not (self == other)
16263 
 
16264 
class markOrderDoaRequestAuthorized_result:
16265 
  """
16266 
  Attributes:
16267 
   - success
16268 
   - ex
16269 
  """
16270 
 
16271 
  thrift_spec = (
16272 
    (0, TType.BOOL, 'success', None, None, ), # 0
16273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16274 
  )
16275 
 
16276 
  def __init__(self, success=None, ex=None,):
16277 
    self.success = success
16278 
    self.ex = ex
16279 
 
16280 
  def read(self, iprot):
16281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16283 
      return
16284 
    iprot.readStructBegin()
16285 
    while True:
16286 
      (fname, ftype, fid) = iprot.readFieldBegin()
16287 
      if ftype == TType.STOP:
16288 
        break
16289 
      if fid == 0:
16290 
        if ftype == TType.BOOL:
16291 
          self.success = iprot.readBool();
16292 
        else:
16293 
          iprot.skip(ftype)
16294 
      elif fid == 1:
16295 
        if ftype == TType.STRUCT:
16296 
          self.ex = TransactionServiceException()
16297 
          self.ex.read(iprot)
16298 
        else:
16299 
          iprot.skip(ftype)
16300 
      else:
16301 
        iprot.skip(ftype)
16302 
      iprot.readFieldEnd()
16303 
    iprot.readStructEnd()
16304 
 
16305 
  def write(self, oprot):
16306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16308 
      return
16309 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16310 
    if self.success is not None:
16311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16312 
      oprot.writeBool(self.success)
16313 
      oprot.writeFieldEnd()
16314 
    if self.ex is not None:
16315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16316 
      self.ex.write(oprot)
16317 
      oprot.writeFieldEnd()
16318 
    oprot.writeFieldStop()
16319 
    oprot.writeStructEnd()
16320 
 
16321 
  def validate(self):
16322 
    return
16323 
 
16324 
 
16325 
  def __repr__(self):
16326 
    L = ['%s=%r' % (key, value)
16327 
      for key, value in self.__dict__.iteritems()]
16328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16329 
 
16330 
  def __eq__(self, other):
16331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16332 
 
16333 
  def __ne__(self, other):
16334 
    return not (self == other)
16335 
 
4488 rajveer 16336 
class markOrderReturnRequestReceived_args:
16337 
  """
16338 
  Attributes:
16339 
   - orderId
16340 
  """
16341 
 
16342 
  thrift_spec = (
16343 
    None, # 0
16344 
    (1, TType.I64, 'orderId', None, None, ), # 1
16345 
  )
16346 
 
16347 
  def __init__(self, orderId=None,):
16348 
    self.orderId = orderId
16349 
 
16350 
  def read(self, iprot):
16351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16353 
      return
16354 
    iprot.readStructBegin()
16355 
    while True:
16356 
      (fname, ftype, fid) = iprot.readFieldBegin()
16357 
      if ftype == TType.STOP:
16358 
        break
16359 
      if fid == 1:
16360 
        if ftype == TType.I64:
16361 
          self.orderId = iprot.readI64();
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('markOrderReturnRequestReceived_args')
16374 
    if self.orderId is not None:
16375 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16376 
      oprot.writeI64(self.orderId)
16377 
      oprot.writeFieldEnd()
16378 
    oprot.writeFieldStop()
16379 
    oprot.writeStructEnd()
16380 
 
16381 
  def validate(self):
16382 
    return
16383 
 
16384 
 
16385 
  def __repr__(self):
16386 
    L = ['%s=%r' % (key, value)
16387 
      for key, value in self.__dict__.iteritems()]
16388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16389 
 
16390 
  def __eq__(self, other):
16391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16392 
 
16393 
  def __ne__(self, other):
16394 
    return not (self == other)
16395 
 
16396 
class markOrderReturnRequestReceived_result:
16397 
  """
16398 
  Attributes:
16399 
   - success
16400 
   - ex
16401 
  """
16402 
 
16403 
  thrift_spec = (
16404 
    (0, TType.BOOL, 'success', None, None, ), # 0
16405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16406 
  )
16407 
 
16408 
  def __init__(self, success=None, ex=None,):
16409 
    self.success = success
16410 
    self.ex = ex
16411 
 
16412 
  def read(self, iprot):
16413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16415 
      return
16416 
    iprot.readStructBegin()
16417 
    while True:
16418 
      (fname, ftype, fid) = iprot.readFieldBegin()
16419 
      if ftype == TType.STOP:
16420 
        break
16421 
      if fid == 0:
16422 
        if ftype == TType.BOOL:
16423 
          self.success = iprot.readBool();
16424 
        else:
16425 
          iprot.skip(ftype)
16426 
      elif fid == 1:
16427 
        if ftype == TType.STRUCT:
16428 
          self.ex = TransactionServiceException()
16429 
          self.ex.read(iprot)
16430 
        else:
16431 
          iprot.skip(ftype)
16432 
      else:
16433 
        iprot.skip(ftype)
16434 
      iprot.readFieldEnd()
16435 
    iprot.readStructEnd()
16436 
 
16437 
  def write(self, oprot):
16438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16440 
      return
16441 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16442 
    if self.success is not None:
16443 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16444 
      oprot.writeBool(self.success)
16445 
      oprot.writeFieldEnd()
16446 
    if self.ex is not None:
16447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16448 
      self.ex.write(oprot)
16449 
      oprot.writeFieldEnd()
16450 
    oprot.writeFieldStop()
16451 
    oprot.writeStructEnd()
16452 
 
16453 
  def validate(self):
16454 
    return
16455 
 
16456 
 
16457 
  def __repr__(self):
16458 
    L = ['%s=%r' % (key, value)
16459 
      for key, value in self.__dict__.iteritems()]
16460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16461 
 
16462 
  def __eq__(self, other):
16463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16464 
 
16465 
  def __ne__(self, other):
16466 
    return not (self == other)
16467 
 
16468 
class markOrderReturnRequestAuthorized_args:
16469 
  """
16470 
  Attributes:
16471 
   - orderId
16472 
   - isAuthorized
16473 
  """
16474 
 
16475 
  thrift_spec = (
16476 
    None, # 0
16477 
    (1, TType.I64, 'orderId', None, None, ), # 1
16478 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16479 
  )
16480 
 
16481 
  def __init__(self, orderId=None, isAuthorized=None,):
16482 
    self.orderId = orderId
16483 
    self.isAuthorized = isAuthorized
16484 
 
16485 
  def read(self, iprot):
16486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16488 
      return
16489 
    iprot.readStructBegin()
16490 
    while True:
16491 
      (fname, ftype, fid) = iprot.readFieldBegin()
16492 
      if ftype == TType.STOP:
16493 
        break
16494 
      if fid == 1:
16495 
        if ftype == TType.I64:
16496 
          self.orderId = iprot.readI64();
16497 
        else:
16498 
          iprot.skip(ftype)
16499 
      elif fid == 2:
16500 
        if ftype == TType.BOOL:
16501 
          self.isAuthorized = iprot.readBool();
16502 
        else:
16503 
          iprot.skip(ftype)
16504 
      else:
16505 
        iprot.skip(ftype)
16506 
      iprot.readFieldEnd()
16507 
    iprot.readStructEnd()
16508 
 
16509 
  def write(self, oprot):
16510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16512 
      return
16513 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16514 
    if self.orderId is not None:
16515 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16516 
      oprot.writeI64(self.orderId)
16517 
      oprot.writeFieldEnd()
16518 
    if self.isAuthorized is not None:
16519 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16520 
      oprot.writeBool(self.isAuthorized)
16521 
      oprot.writeFieldEnd()
16522 
    oprot.writeFieldStop()
16523 
    oprot.writeStructEnd()
16524 
 
16525 
  def validate(self):
16526 
    return
16527 
 
16528 
 
16529 
  def __repr__(self):
16530 
    L = ['%s=%r' % (key, value)
16531 
      for key, value in self.__dict__.iteritems()]
16532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16533 
 
16534 
  def __eq__(self, other):
16535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16536 
 
16537 
  def __ne__(self, other):
16538 
    return not (self == other)
16539 
 
16540 
class markOrderReturnRequestAuthorized_result:
16541 
  """
16542 
  Attributes:
16543 
   - success
16544 
   - ex
16545 
  """
16546 
 
16547 
  thrift_spec = (
16548 
    (0, TType.BOOL, 'success', None, None, ), # 0
16549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16550 
  )
16551 
 
16552 
  def __init__(self, success=None, ex=None,):
16553 
    self.success = success
16554 
    self.ex = ex
16555 
 
16556 
  def read(self, iprot):
16557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16559 
      return
16560 
    iprot.readStructBegin()
16561 
    while True:
16562 
      (fname, ftype, fid) = iprot.readFieldBegin()
16563 
      if ftype == TType.STOP:
16564 
        break
16565 
      if fid == 0:
16566 
        if ftype == TType.BOOL:
16567 
          self.success = iprot.readBool();
16568 
        else:
16569 
          iprot.skip(ftype)
16570 
      elif fid == 1:
16571 
        if ftype == TType.STRUCT:
16572 
          self.ex = TransactionServiceException()
16573 
          self.ex.read(iprot)
16574 
        else:
16575 
          iprot.skip(ftype)
16576 
      else:
16577 
        iprot.skip(ftype)
16578 
      iprot.readFieldEnd()
16579 
    iprot.readStructEnd()
16580 
 
16581 
  def write(self, oprot):
16582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16584 
      return
16585 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16586 
    if self.success is not None:
16587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16588 
      oprot.writeBool(self.success)
16589 
      oprot.writeFieldEnd()
16590 
    if self.ex is not None:
16591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16592 
      self.ex.write(oprot)
16593 
      oprot.writeFieldEnd()
16594 
    oprot.writeFieldStop()
16595 
    oprot.writeStructEnd()
16596 
 
16597 
  def validate(self):
16598 
    return
16599 
 
16600 
 
16601 
  def __repr__(self):
16602 
    L = ['%s=%r' % (key, value)
16603 
      for key, value in self.__dict__.iteritems()]
16604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16605 
 
16606 
  def __eq__(self, other):
16607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16608 
 
16609 
  def __ne__(self, other):
16610 
    return not (self == other)
16611 
 
2536 chandransh 16612 
class requestPickupNumber_args:
16613 
  """
16614 
  Attributes:
16615 
   - orderId
4579 rajveer 16616 
   - providerId
2536 chandransh 16617 
  """
16618 
 
16619 
  thrift_spec = (
16620 
    None, # 0
16621 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16622 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16623 
  )
16624 
 
4579 rajveer 16625 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16626 
    self.orderId = orderId
4579 rajveer 16627 
    self.providerId = providerId
2536 chandransh 16628 
 
16629 
  def read(self, iprot):
16630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16632 
      return
16633 
    iprot.readStructBegin()
16634 
    while True:
16635 
      (fname, ftype, fid) = iprot.readFieldBegin()
16636 
      if ftype == TType.STOP:
16637 
        break
16638 
      if fid == 1:
16639 
        if ftype == TType.I64:
16640 
          self.orderId = iprot.readI64();
16641 
        else:
16642 
          iprot.skip(ftype)
4579 rajveer 16643 
      elif fid == 2:
16644 
        if ftype == TType.I64:
16645 
          self.providerId = iprot.readI64();
16646 
        else:
16647 
          iprot.skip(ftype)
2536 chandransh 16648 
      else:
16649 
        iprot.skip(ftype)
16650 
      iprot.readFieldEnd()
16651 
    iprot.readStructEnd()
16652 
 
16653 
  def write(self, oprot):
16654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16656 
      return
16657 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16658 
    if self.orderId is not None:
2536 chandransh 16659 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16660 
      oprot.writeI64(self.orderId)
16661 
      oprot.writeFieldEnd()
4579 rajveer 16662 
    if self.providerId is not None:
16663 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16664 
      oprot.writeI64(self.providerId)
16665 
      oprot.writeFieldEnd()
2536 chandransh 16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
3431 rajveer 16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
2536 chandransh 16673 
  def __repr__(self):
16674 
    L = ['%s=%r' % (key, value)
16675 
      for key, value in self.__dict__.iteritems()]
16676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16677 
 
16678 
  def __eq__(self, other):
16679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16680 
 
16681 
  def __ne__(self, other):
16682 
    return not (self == other)
16683 
 
16684 
class requestPickupNumber_result:
16685 
  """
16686 
  Attributes:
16687 
   - success
16688 
   - ex
16689 
  """
16690 
 
16691 
  thrift_spec = (
16692 
    (0, TType.BOOL, 'success', None, None, ), # 0
16693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16694 
  )
16695 
 
16696 
  def __init__(self, success=None, ex=None,):
16697 
    self.success = success
16698 
    self.ex = ex
16699 
 
16700 
  def read(self, iprot):
16701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16703 
      return
16704 
    iprot.readStructBegin()
16705 
    while True:
16706 
      (fname, ftype, fid) = iprot.readFieldBegin()
16707 
      if ftype == TType.STOP:
16708 
        break
16709 
      if fid == 0:
16710 
        if ftype == TType.BOOL:
16711 
          self.success = iprot.readBool();
16712 
        else:
16713 
          iprot.skip(ftype)
16714 
      elif fid == 1:
16715 
        if ftype == TType.STRUCT:
16716 
          self.ex = TransactionServiceException()
16717 
          self.ex.read(iprot)
16718 
        else:
16719 
          iprot.skip(ftype)
16720 
      else:
16721 
        iprot.skip(ftype)
16722 
      iprot.readFieldEnd()
16723 
    iprot.readStructEnd()
16724 
 
16725 
  def write(self, oprot):
16726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16728 
      return
16729 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16730 
    if self.success is not None:
2536 chandransh 16731 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16732 
      oprot.writeBool(self.success)
16733 
      oprot.writeFieldEnd()
3431 rajveer 16734 
    if self.ex is not None:
2536 chandransh 16735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16736 
      self.ex.write(oprot)
16737 
      oprot.writeFieldEnd()
16738 
    oprot.writeFieldStop()
16739 
    oprot.writeStructEnd()
16740 
 
3431 rajveer 16741 
  def validate(self):
16742 
    return
16743 
 
16744 
 
2536 chandransh 16745 
  def __repr__(self):
16746 
    L = ['%s=%r' % (key, value)
16747 
      for key, value in self.__dict__.iteritems()]
16748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16749 
 
16750 
  def __eq__(self, other):
16751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16752 
 
16753 
  def __ne__(self, other):
16754 
    return not (self == other)
16755 
 
16756 
class authorizePickup_args:
16757 
  """
16758 
  Attributes:
16759 
   - orderId
16760 
   - pickupNumber
4602 rajveer 16761 
   - providerId
2536 chandransh 16762 
  """
16763 
 
16764 
  thrift_spec = (
16765 
    None, # 0
16766 
    (1, TType.I64, 'orderId', None, None, ), # 1
16767 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16768 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16769 
  )
16770 
 
4602 rajveer 16771 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16772 
    self.orderId = orderId
16773 
    self.pickupNumber = pickupNumber
4602 rajveer 16774 
    self.providerId = providerId
2536 chandransh 16775 
 
16776 
  def read(self, iprot):
16777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16779 
      return
16780 
    iprot.readStructBegin()
16781 
    while True:
16782 
      (fname, ftype, fid) = iprot.readFieldBegin()
16783 
      if ftype == TType.STOP:
16784 
        break
16785 
      if fid == 1:
16786 
        if ftype == TType.I64:
16787 
          self.orderId = iprot.readI64();
16788 
        else:
16789 
          iprot.skip(ftype)
16790 
      elif fid == 2:
16791 
        if ftype == TType.STRING:
16792 
          self.pickupNumber = iprot.readString();
16793 
        else:
16794 
          iprot.skip(ftype)
4602 rajveer 16795 
      elif fid == 3:
16796 
        if ftype == TType.I64:
16797 
          self.providerId = iprot.readI64();
16798 
        else:
16799 
          iprot.skip(ftype)
2536 chandransh 16800 
      else:
16801 
        iprot.skip(ftype)
16802 
      iprot.readFieldEnd()
16803 
    iprot.readStructEnd()
16804 
 
16805 
  def write(self, oprot):
16806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16808 
      return
16809 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16810 
    if self.orderId is not None:
2536 chandransh 16811 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16812 
      oprot.writeI64(self.orderId)
16813 
      oprot.writeFieldEnd()
3431 rajveer 16814 
    if self.pickupNumber is not None:
2536 chandransh 16815 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16816 
      oprot.writeString(self.pickupNumber)
16817 
      oprot.writeFieldEnd()
4602 rajveer 16818 
    if self.providerId is not None:
16819 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16820 
      oprot.writeI64(self.providerId)
16821 
      oprot.writeFieldEnd()
2536 chandransh 16822 
    oprot.writeFieldStop()
16823 
    oprot.writeStructEnd()
16824 
 
3431 rajveer 16825 
  def validate(self):
16826 
    return
16827 
 
16828 
 
2536 chandransh 16829 
  def __repr__(self):
16830 
    L = ['%s=%r' % (key, value)
16831 
      for key, value in self.__dict__.iteritems()]
16832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16833 
 
16834 
  def __eq__(self, other):
16835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16836 
 
16837 
  def __ne__(self, other):
16838 
    return not (self == other)
16839 
 
16840 
class authorizePickup_result:
16841 
  """
16842 
  Attributes:
16843 
   - success
16844 
   - ex
16845 
  """
16846 
 
16847 
  thrift_spec = (
16848 
    (0, TType.BOOL, 'success', None, None, ), # 0
16849 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16850 
  )
16851 
 
16852 
  def __init__(self, success=None, ex=None,):
16853 
    self.success = success
16854 
    self.ex = ex
16855 
 
16856 
  def read(self, iprot):
16857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16859 
      return
16860 
    iprot.readStructBegin()
16861 
    while True:
16862 
      (fname, ftype, fid) = iprot.readFieldBegin()
16863 
      if ftype == TType.STOP:
16864 
        break
16865 
      if fid == 0:
16866 
        if ftype == TType.BOOL:
16867 
          self.success = iprot.readBool();
16868 
        else:
16869 
          iprot.skip(ftype)
16870 
      elif fid == 1:
16871 
        if ftype == TType.STRUCT:
16872 
          self.ex = TransactionServiceException()
16873 
          self.ex.read(iprot)
16874 
        else:
16875 
          iprot.skip(ftype)
16876 
      else:
16877 
        iprot.skip(ftype)
16878 
      iprot.readFieldEnd()
16879 
    iprot.readStructEnd()
16880 
 
16881 
  def write(self, oprot):
16882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16884 
      return
16885 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16886 
    if self.success is not None:
2536 chandransh 16887 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16888 
      oprot.writeBool(self.success)
16889 
      oprot.writeFieldEnd()
3431 rajveer 16890 
    if self.ex is not None:
2536 chandransh 16891 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16892 
      self.ex.write(oprot)
16893 
      oprot.writeFieldEnd()
16894 
    oprot.writeFieldStop()
16895 
    oprot.writeStructEnd()
16896 
 
3431 rajveer 16897 
  def validate(self):
16898 
    return
16899 
 
16900 
 
2536 chandransh 16901 
  def __repr__(self):
16902 
    L = ['%s=%r' % (key, value)
16903 
      for key, value in self.__dict__.iteritems()]
16904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16905 
 
16906 
  def __eq__(self, other):
16907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16908 
 
16909 
  def __ne__(self, other):
16910 
    return not (self == other)
16911 
 
2764 chandransh 16912 
class markDoasAsPickedUp_args:
16913 
  """
16914 
  Attributes:
16915 
   - providerId
16916 
   - pickupDetails
16917 
  """
16918 
 
16919 
  thrift_spec = (
16920 
    None, # 0
16921 
    (1, TType.I64, 'providerId', None, None, ), # 1
16922 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16923 
  )
16924 
 
16925 
  def __init__(self, providerId=None, pickupDetails=None,):
16926 
    self.providerId = providerId
16927 
    self.pickupDetails = pickupDetails
16928 
 
16929 
  def read(self, iprot):
16930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16932 
      return
16933 
    iprot.readStructBegin()
16934 
    while True:
16935 
      (fname, ftype, fid) = iprot.readFieldBegin()
16936 
      if ftype == TType.STOP:
16937 
        break
16938 
      if fid == 1:
16939 
        if ftype == TType.I64:
16940 
          self.providerId = iprot.readI64();
16941 
        else:
16942 
          iprot.skip(ftype)
16943 
      elif fid == 2:
16944 
        if ftype == TType.MAP:
16945 
          self.pickupDetails = {}
6031 rajveer 16946 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16947 
          for _i368 in xrange(_size364):
16948 
            _key369 = iprot.readString();
16949 
            _val370 = iprot.readString();
16950 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16951 
          iprot.readMapEnd()
16952 
        else:
16953 
          iprot.skip(ftype)
16954 
      else:
16955 
        iprot.skip(ftype)
16956 
      iprot.readFieldEnd()
16957 
    iprot.readStructEnd()
16958 
 
16959 
  def write(self, oprot):
16960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16962 
      return
16963 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16964 
    if self.providerId is not None:
2764 chandransh 16965 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16966 
      oprot.writeI64(self.providerId)
16967 
      oprot.writeFieldEnd()
3431 rajveer 16968 
    if self.pickupDetails is not None:
2764 chandransh 16969 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16970 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 16971 
      for kiter371,viter372 in self.pickupDetails.items():
16972 
        oprot.writeString(kiter371)
16973 
        oprot.writeString(viter372)
2764 chandransh 16974 
      oprot.writeMapEnd()
16975 
      oprot.writeFieldEnd()
16976 
    oprot.writeFieldStop()
16977 
    oprot.writeStructEnd()
16978 
 
3431 rajveer 16979 
  def validate(self):
16980 
    return
16981 
 
16982 
 
2764 chandransh 16983 
  def __repr__(self):
16984 
    L = ['%s=%r' % (key, value)
16985 
      for key, value in self.__dict__.iteritems()]
16986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16987 
 
16988 
  def __eq__(self, other):
16989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16990 
 
16991 
  def __ne__(self, other):
16992 
    return not (self == other)
16993 
 
16994 
class markDoasAsPickedUp_result:
4910 phani.kuma 16995 
 
16996 
  thrift_spec = (
16997 
  )
16998 
 
16999 
  def read(self, iprot):
17000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17002 
      return
17003 
    iprot.readStructBegin()
17004 
    while True:
17005 
      (fname, ftype, fid) = iprot.readFieldBegin()
17006 
      if ftype == TType.STOP:
17007 
        break
17008 
      else:
17009 
        iprot.skip(ftype)
17010 
      iprot.readFieldEnd()
17011 
    iprot.readStructEnd()
17012 
 
17013 
  def write(self, oprot):
17014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17016 
      return
17017 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17018 
    oprot.writeFieldStop()
17019 
    oprot.writeStructEnd()
17020 
 
17021 
  def validate(self):
17022 
    return
17023 
 
17024 
 
17025 
  def __repr__(self):
17026 
    L = ['%s=%r' % (key, value)
17027 
      for key, value in self.__dict__.iteritems()]
17028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17029 
 
17030 
  def __eq__(self, other):
17031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17032 
 
17033 
  def __ne__(self, other):
17034 
    return not (self == other)
17035 
 
17036 
class getDoasNotPickedUp_args:
2764 chandransh 17037 
  """
17038 
  Attributes:
4910 phani.kuma 17039 
   - providerId
17040 
  """
17041 
 
17042 
  thrift_spec = (
17043 
    None, # 0
17044 
    (1, TType.I64, 'providerId', None, None, ), # 1
17045 
  )
17046 
 
17047 
  def __init__(self, providerId=None,):
17048 
    self.providerId = providerId
17049 
 
17050 
  def read(self, iprot):
17051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17053 
      return
17054 
    iprot.readStructBegin()
17055 
    while True:
17056 
      (fname, ftype, fid) = iprot.readFieldBegin()
17057 
      if ftype == TType.STOP:
17058 
        break
17059 
      if fid == 1:
17060 
        if ftype == TType.I64:
17061 
          self.providerId = iprot.readI64();
17062 
        else:
17063 
          iprot.skip(ftype)
17064 
      else:
17065 
        iprot.skip(ftype)
17066 
      iprot.readFieldEnd()
17067 
    iprot.readStructEnd()
17068 
 
17069 
  def write(self, oprot):
17070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17072 
      return
17073 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17074 
    if self.providerId is not None:
17075 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17076 
      oprot.writeI64(self.providerId)
17077 
      oprot.writeFieldEnd()
17078 
    oprot.writeFieldStop()
17079 
    oprot.writeStructEnd()
17080 
 
17081 
  def validate(self):
17082 
    return
17083 
 
17084 
 
17085 
  def __repr__(self):
17086 
    L = ['%s=%r' % (key, value)
17087 
      for key, value in self.__dict__.iteritems()]
17088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17089 
 
17090 
  def __eq__(self, other):
17091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17092 
 
17093 
  def __ne__(self, other):
17094 
    return not (self == other)
17095 
 
17096 
class getDoasNotPickedUp_result:
17097 
  """
17098 
  Attributes:
2764 chandransh 17099 
   - success
17100 
  """
17101 
 
17102 
  thrift_spec = (
17103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17104 
  )
17105 
 
17106 
  def __init__(self, success=None,):
17107 
    self.success = success
17108 
 
17109 
  def read(self, iprot):
17110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17112 
      return
17113 
    iprot.readStructBegin()
17114 
    while True:
17115 
      (fname, ftype, fid) = iprot.readFieldBegin()
17116 
      if ftype == TType.STOP:
17117 
        break
17118 
      if fid == 0:
17119 
        if ftype == TType.LIST:
17120 
          self.success = []
6031 rajveer 17121 
          (_etype376, _size373) = iprot.readListBegin()
17122 
          for _i377 in xrange(_size373):
17123 
            _elem378 = Order()
17124 
            _elem378.read(iprot)
17125 
            self.success.append(_elem378)
2764 chandransh 17126 
          iprot.readListEnd()
17127 
        else:
17128 
          iprot.skip(ftype)
17129 
      else:
17130 
        iprot.skip(ftype)
17131 
      iprot.readFieldEnd()
17132 
    iprot.readStructEnd()
17133 
 
17134 
  def write(self, oprot):
17135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17137 
      return
4910 phani.kuma 17138 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17139 
    if self.success is not None:
2764 chandransh 17140 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17141 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17142 
      for iter379 in self.success:
17143 
        iter379.write(oprot)
2764 chandransh 17144 
      oprot.writeListEnd()
17145 
      oprot.writeFieldEnd()
17146 
    oprot.writeFieldStop()
17147 
    oprot.writeStructEnd()
17148 
 
3431 rajveer 17149 
  def validate(self):
17150 
    return
17151 
 
17152 
 
2764 chandransh 17153 
  def __repr__(self):
17154 
    L = ['%s=%r' % (key, value)
17155 
      for key, value in self.__dict__.iteritems()]
17156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17157 
 
17158 
  def __eq__(self, other):
17159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17160 
 
17161 
  def __ne__(self, other):
17162 
    return not (self == other)
17163 
 
4741 phani.kuma 17164 
class markReturnOrdersAsPickedUp_args:
17165 
  """
17166 
  Attributes:
17167 
   - providerId
17168 
   - pickupDetails
17169 
  """
17170 
 
17171 
  thrift_spec = (
17172 
    None, # 0
17173 
    (1, TType.I64, 'providerId', None, None, ), # 1
17174 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17175 
  )
17176 
 
17177 
  def __init__(self, providerId=None, pickupDetails=None,):
17178 
    self.providerId = providerId
17179 
    self.pickupDetails = pickupDetails
17180 
 
17181 
  def read(self, iprot):
17182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17184 
      return
17185 
    iprot.readStructBegin()
17186 
    while True:
17187 
      (fname, ftype, fid) = iprot.readFieldBegin()
17188 
      if ftype == TType.STOP:
17189 
        break
17190 
      if fid == 1:
17191 
        if ftype == TType.I64:
17192 
          self.providerId = iprot.readI64();
17193 
        else:
17194 
          iprot.skip(ftype)
17195 
      elif fid == 2:
17196 
        if ftype == TType.MAP:
17197 
          self.pickupDetails = {}
6031 rajveer 17198 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
17199 
          for _i384 in xrange(_size380):
17200 
            _key385 = iprot.readString();
17201 
            _val386 = iprot.readString();
17202 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 17203 
          iprot.readMapEnd()
17204 
        else:
17205 
          iprot.skip(ftype)
17206 
      else:
17207 
        iprot.skip(ftype)
17208 
      iprot.readFieldEnd()
17209 
    iprot.readStructEnd()
17210 
 
17211 
  def write(self, oprot):
17212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17214 
      return
17215 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17216 
    if self.providerId is not None:
17217 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17218 
      oprot.writeI64(self.providerId)
17219 
      oprot.writeFieldEnd()
17220 
    if self.pickupDetails is not None:
17221 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17222 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 17223 
      for kiter387,viter388 in self.pickupDetails.items():
17224 
        oprot.writeString(kiter387)
17225 
        oprot.writeString(viter388)
4741 phani.kuma 17226 
      oprot.writeMapEnd()
17227 
      oprot.writeFieldEnd()
17228 
    oprot.writeFieldStop()
17229 
    oprot.writeStructEnd()
17230 
 
17231 
  def validate(self):
17232 
    return
17233 
 
17234 
 
17235 
  def __repr__(self):
17236 
    L = ['%s=%r' % (key, value)
17237 
      for key, value in self.__dict__.iteritems()]
17238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17239 
 
17240 
  def __eq__(self, other):
17241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17242 
 
17243 
  def __ne__(self, other):
17244 
    return not (self == other)
17245 
 
17246 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17247 
 
17248 
  thrift_spec = (
17249 
  )
17250 
 
17251 
  def read(self, iprot):
17252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17254 
      return
17255 
    iprot.readStructBegin()
17256 
    while True:
17257 
      (fname, ftype, fid) = iprot.readFieldBegin()
17258 
      if ftype == TType.STOP:
17259 
        break
17260 
      else:
17261 
        iprot.skip(ftype)
17262 
      iprot.readFieldEnd()
17263 
    iprot.readStructEnd()
17264 
 
17265 
  def write(self, oprot):
17266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17268 
      return
17269 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17270 
    oprot.writeFieldStop()
17271 
    oprot.writeStructEnd()
17272 
 
17273 
  def validate(self):
17274 
    return
17275 
 
17276 
 
17277 
  def __repr__(self):
17278 
    L = ['%s=%r' % (key, value)
17279 
      for key, value in self.__dict__.iteritems()]
17280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17281 
 
17282 
  def __eq__(self, other):
17283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17284 
 
17285 
  def __ne__(self, other):
17286 
    return not (self == other)
17287 
 
17288 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17289 
  """
17290 
  Attributes:
4910 phani.kuma 17291 
   - providerId
17292 
  """
17293 
 
17294 
  thrift_spec = (
17295 
    None, # 0
17296 
    (1, TType.I64, 'providerId', None, None, ), # 1
17297 
  )
17298 
 
17299 
  def __init__(self, providerId=None,):
17300 
    self.providerId = providerId
17301 
 
17302 
  def read(self, iprot):
17303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17305 
      return
17306 
    iprot.readStructBegin()
17307 
    while True:
17308 
      (fname, ftype, fid) = iprot.readFieldBegin()
17309 
      if ftype == TType.STOP:
17310 
        break
17311 
      if fid == 1:
17312 
        if ftype == TType.I64:
17313 
          self.providerId = iprot.readI64();
17314 
        else:
17315 
          iprot.skip(ftype)
17316 
      else:
17317 
        iprot.skip(ftype)
17318 
      iprot.readFieldEnd()
17319 
    iprot.readStructEnd()
17320 
 
17321 
  def write(self, oprot):
17322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17324 
      return
17325 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17326 
    if self.providerId is not None:
17327 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17328 
      oprot.writeI64(self.providerId)
17329 
      oprot.writeFieldEnd()
17330 
    oprot.writeFieldStop()
17331 
    oprot.writeStructEnd()
17332 
 
17333 
  def validate(self):
17334 
    return
17335 
 
17336 
 
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 getReturnOrdersNotPickedUp_result:
17349 
  """
17350 
  Attributes:
4741 phani.kuma 17351 
   - success
17352 
  """
17353 
 
17354 
  thrift_spec = (
17355 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17356 
  )
17357 
 
17358 
  def __init__(self, success=None,):
17359 
    self.success = success
17360 
 
17361 
  def read(self, iprot):
17362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17364 
      return
17365 
    iprot.readStructBegin()
17366 
    while True:
17367 
      (fname, ftype, fid) = iprot.readFieldBegin()
17368 
      if ftype == TType.STOP:
17369 
        break
17370 
      if fid == 0:
17371 
        if ftype == TType.LIST:
17372 
          self.success = []
6031 rajveer 17373 
          (_etype392, _size389) = iprot.readListBegin()
17374 
          for _i393 in xrange(_size389):
17375 
            _elem394 = Order()
17376 
            _elem394.read(iprot)
17377 
            self.success.append(_elem394)
4741 phani.kuma 17378 
          iprot.readListEnd()
17379 
        else:
17380 
          iprot.skip(ftype)
17381 
      else:
17382 
        iprot.skip(ftype)
17383 
      iprot.readFieldEnd()
17384 
    iprot.readStructEnd()
17385 
 
17386 
  def write(self, oprot):
17387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17389 
      return
4910 phani.kuma 17390 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17391 
    if self.success is not None:
17392 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17393 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17394 
      for iter395 in self.success:
17395 
        iter395.write(oprot)
4741 phani.kuma 17396 
      oprot.writeListEnd()
17397 
      oprot.writeFieldEnd()
17398 
    oprot.writeFieldStop()
17399 
    oprot.writeStructEnd()
17400 
 
17401 
  def validate(self):
17402 
    return
17403 
 
17404 
 
17405 
  def __repr__(self):
17406 
    L = ['%s=%r' % (key, value)
17407 
      for key, value in self.__dict__.iteritems()]
17408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17409 
 
17410 
  def __eq__(self, other):
17411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17412 
 
17413 
  def __ne__(self, other):
17414 
    return not (self == other)
17415 
 
2616 chandransh 17416 
class receiveReturn_args:
2591 chandransh 17417 
  """
17418 
  Attributes:
17419 
   - orderId
4479 rajveer 17420 
   - receiveCondition
2591 chandransh 17421 
  """
2536 chandransh 17422 
 
2591 chandransh 17423 
  thrift_spec = (
17424 
    None, # 0
17425 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17426 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17427 
  )
17428 
 
4479 rajveer 17429 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17430 
    self.orderId = orderId
4479 rajveer 17431 
    self.receiveCondition = receiveCondition
2591 chandransh 17432 
 
17433 
  def read(self, iprot):
17434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17436 
      return
17437 
    iprot.readStructBegin()
17438 
    while True:
17439 
      (fname, ftype, fid) = iprot.readFieldBegin()
17440 
      if ftype == TType.STOP:
17441 
        break
17442 
      if fid == 1:
17443 
        if ftype == TType.I64:
17444 
          self.orderId = iprot.readI64();
17445 
        else:
17446 
          iprot.skip(ftype)
4479 rajveer 17447 
      elif fid == 2:
17448 
        if ftype == TType.I64:
17449 
          self.receiveCondition = iprot.readI64();
17450 
        else:
17451 
          iprot.skip(ftype)
2591 chandransh 17452 
      else:
17453 
        iprot.skip(ftype)
17454 
      iprot.readFieldEnd()
17455 
    iprot.readStructEnd()
17456 
 
17457 
  def write(self, oprot):
17458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17460 
      return
2616 chandransh 17461 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17462 
    if self.orderId is not None:
2591 chandransh 17463 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17464 
      oprot.writeI64(self.orderId)
17465 
      oprot.writeFieldEnd()
4479 rajveer 17466 
    if self.receiveCondition is not None:
17467 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17468 
      oprot.writeI64(self.receiveCondition)
17469 
      oprot.writeFieldEnd()
2591 chandransh 17470 
    oprot.writeFieldStop()
17471 
    oprot.writeStructEnd()
17472 
 
3431 rajveer 17473 
  def validate(self):
17474 
    return
17475 
 
17476 
 
2591 chandransh 17477 
  def __repr__(self):
17478 
    L = ['%s=%r' % (key, value)
17479 
      for key, value in self.__dict__.iteritems()]
17480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17481 
 
17482 
  def __eq__(self, other):
17483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17484 
 
17485 
  def __ne__(self, other):
17486 
    return not (self == other)
17487 
 
2616 chandransh 17488 
class receiveReturn_result:
2591 chandransh 17489 
  """
17490 
  Attributes:
17491 
   - success
17492 
   - ex
17493 
  """
17494 
 
17495 
  thrift_spec = (
17496 
    (0, TType.BOOL, 'success', None, None, ), # 0
17497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17498 
  )
17499 
 
17500 
  def __init__(self, success=None, ex=None,):
17501 
    self.success = success
17502 
    self.ex = ex
17503 
 
17504 
  def read(self, iprot):
17505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17507 
      return
17508 
    iprot.readStructBegin()
17509 
    while True:
17510 
      (fname, ftype, fid) = iprot.readFieldBegin()
17511 
      if ftype == TType.STOP:
17512 
        break
17513 
      if fid == 0:
17514 
        if ftype == TType.BOOL:
17515 
          self.success = iprot.readBool();
17516 
        else:
17517 
          iprot.skip(ftype)
17518 
      elif fid == 1:
17519 
        if ftype == TType.STRUCT:
17520 
          self.ex = TransactionServiceException()
17521 
          self.ex.read(iprot)
17522 
        else:
17523 
          iprot.skip(ftype)
17524 
      else:
17525 
        iprot.skip(ftype)
17526 
      iprot.readFieldEnd()
17527 
    iprot.readStructEnd()
17528 
 
17529 
  def write(self, oprot):
17530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17532 
      return
2616 chandransh 17533 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17534 
    if self.success is not None:
2591 chandransh 17535 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17536 
      oprot.writeBool(self.success)
17537 
      oprot.writeFieldEnd()
3431 rajveer 17538 
    if self.ex is not None:
2591 chandransh 17539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17540 
      self.ex.write(oprot)
17541 
      oprot.writeFieldEnd()
17542 
    oprot.writeFieldStop()
17543 
    oprot.writeStructEnd()
17544 
 
3431 rajveer 17545 
  def validate(self):
17546 
    return
17547 
 
17548 
 
2591 chandransh 17549 
  def __repr__(self):
17550 
    L = ['%s=%r' % (key, value)
17551 
      for key, value in self.__dict__.iteritems()]
17552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17553 
 
17554 
  def __eq__(self, other):
17555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17556 
 
17557 
  def __ne__(self, other):
17558 
    return not (self == other)
17559 
 
17560 
class validateDoa_args:
17561 
  """
17562 
  Attributes:
17563 
   - orderId
17564 
   - isValid
17565 
  """
17566 
 
17567 
  thrift_spec = (
17568 
    None, # 0
17569 
    (1, TType.I64, 'orderId', None, None, ), # 1
17570 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17571 
  )
17572 
 
17573 
  def __init__(self, orderId=None, isValid=None,):
17574 
    self.orderId = orderId
17575 
    self.isValid = isValid
17576 
 
17577 
  def read(self, iprot):
17578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17580 
      return
17581 
    iprot.readStructBegin()
17582 
    while True:
17583 
      (fname, ftype, fid) = iprot.readFieldBegin()
17584 
      if ftype == TType.STOP:
17585 
        break
17586 
      if fid == 1:
17587 
        if ftype == TType.I64:
17588 
          self.orderId = iprot.readI64();
17589 
        else:
17590 
          iprot.skip(ftype)
17591 
      elif fid == 2:
17592 
        if ftype == TType.BOOL:
17593 
          self.isValid = iprot.readBool();
17594 
        else:
17595 
          iprot.skip(ftype)
17596 
      else:
17597 
        iprot.skip(ftype)
17598 
      iprot.readFieldEnd()
17599 
    iprot.readStructEnd()
17600 
 
17601 
  def write(self, oprot):
17602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17604 
      return
17605 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17606 
    if self.orderId is not None:
2591 chandransh 17607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17608 
      oprot.writeI64(self.orderId)
17609 
      oprot.writeFieldEnd()
3431 rajveer 17610 
    if self.isValid is not None:
2591 chandransh 17611 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17612 
      oprot.writeBool(self.isValid)
17613 
      oprot.writeFieldEnd()
17614 
    oprot.writeFieldStop()
17615 
    oprot.writeStructEnd()
17616 
 
3431 rajveer 17617 
  def validate(self):
17618 
    return
17619 
 
17620 
 
2591 chandransh 17621 
  def __repr__(self):
17622 
    L = ['%s=%r' % (key, value)
17623 
      for key, value in self.__dict__.iteritems()]
17624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17625 
 
17626 
  def __eq__(self, other):
17627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17628 
 
17629 
  def __ne__(self, other):
17630 
    return not (self == other)
17631 
 
17632 
class validateDoa_result:
17633 
  """
17634 
  Attributes:
17635 
   - success
17636 
   - ex
17637 
  """
17638 
 
17639 
  thrift_spec = (
17640 
    (0, TType.BOOL, 'success', None, None, ), # 0
17641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17642 
  )
17643 
 
17644 
  def __init__(self, success=None, ex=None,):
17645 
    self.success = success
17646 
    self.ex = ex
17647 
 
17648 
  def read(self, iprot):
17649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17651 
      return
17652 
    iprot.readStructBegin()
17653 
    while True:
17654 
      (fname, ftype, fid) = iprot.readFieldBegin()
17655 
      if ftype == TType.STOP:
17656 
        break
17657 
      if fid == 0:
17658 
        if ftype == TType.BOOL:
17659 
          self.success = iprot.readBool();
17660 
        else:
17661 
          iprot.skip(ftype)
17662 
      elif fid == 1:
17663 
        if ftype == TType.STRUCT:
17664 
          self.ex = TransactionServiceException()
17665 
          self.ex.read(iprot)
17666 
        else:
17667 
          iprot.skip(ftype)
17668 
      else:
17669 
        iprot.skip(ftype)
17670 
      iprot.readFieldEnd()
17671 
    iprot.readStructEnd()
17672 
 
17673 
  def write(self, oprot):
17674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17676 
      return
17677 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17678 
    if self.success is not None:
2591 chandransh 17679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17680 
      oprot.writeBool(self.success)
17681 
      oprot.writeFieldEnd()
3431 rajveer 17682 
    if self.ex is not None:
2591 chandransh 17683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17684 
      self.ex.write(oprot)
17685 
      oprot.writeFieldEnd()
17686 
    oprot.writeFieldStop()
17687 
    oprot.writeStructEnd()
17688 
 
3431 rajveer 17689 
  def validate(self):
17690 
    return
17691 
 
17692 
 
2591 chandransh 17693 
  def __repr__(self):
17694 
    L = ['%s=%r' % (key, value)
17695 
      for key, value in self.__dict__.iteritems()]
17696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17697 
 
17698 
  def __eq__(self, other):
17699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17700 
 
17701 
  def __ne__(self, other):
17702 
    return not (self == other)
17703 
 
4495 rajveer 17704 
class validateReturnProduct_args:
17705 
  """
17706 
  Attributes:
17707 
   - orderId
17708 
   - isUsable
17709 
  """
17710 
 
17711 
  thrift_spec = (
17712 
    None, # 0
17713 
    (1, TType.I64, 'orderId', None, None, ), # 1
17714 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17715 
  )
17716 
 
17717 
  def __init__(self, orderId=None, isUsable=None,):
17718 
    self.orderId = orderId
17719 
    self.isUsable = isUsable
17720 
 
17721 
  def read(self, iprot):
17722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17724 
      return
17725 
    iprot.readStructBegin()
17726 
    while True:
17727 
      (fname, ftype, fid) = iprot.readFieldBegin()
17728 
      if ftype == TType.STOP:
17729 
        break
17730 
      if fid == 1:
17731 
        if ftype == TType.I64:
17732 
          self.orderId = iprot.readI64();
17733 
        else:
17734 
          iprot.skip(ftype)
17735 
      elif fid == 2:
17736 
        if ftype == TType.BOOL:
17737 
          self.isUsable = iprot.readBool();
17738 
        else:
17739 
          iprot.skip(ftype)
17740 
      else:
17741 
        iprot.skip(ftype)
17742 
      iprot.readFieldEnd()
17743 
    iprot.readStructEnd()
17744 
 
17745 
  def write(self, oprot):
17746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17748 
      return
17749 
    oprot.writeStructBegin('validateReturnProduct_args')
17750 
    if self.orderId is not None:
17751 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17752 
      oprot.writeI64(self.orderId)
17753 
      oprot.writeFieldEnd()
17754 
    if self.isUsable is not None:
17755 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17756 
      oprot.writeBool(self.isUsable)
17757 
      oprot.writeFieldEnd()
17758 
    oprot.writeFieldStop()
17759 
    oprot.writeStructEnd()
17760 
 
17761 
  def validate(self):
17762 
    return
17763 
 
17764 
 
17765 
  def __repr__(self):
17766 
    L = ['%s=%r' % (key, value)
17767 
      for key, value in self.__dict__.iteritems()]
17768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17769 
 
17770 
  def __eq__(self, other):
17771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17772 
 
17773 
  def __ne__(self, other):
17774 
    return not (self == other)
17775 
 
17776 
class validateReturnProduct_result:
17777 
  """
17778 
  Attributes:
17779 
   - success
17780 
   - ex
17781 
  """
17782 
 
17783 
  thrift_spec = (
17784 
    (0, TType.BOOL, 'success', None, None, ), # 0
17785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17786 
  )
17787 
 
17788 
  def __init__(self, success=None, ex=None,):
17789 
    self.success = success
17790 
    self.ex = ex
17791 
 
17792 
  def read(self, iprot):
17793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17795 
      return
17796 
    iprot.readStructBegin()
17797 
    while True:
17798 
      (fname, ftype, fid) = iprot.readFieldBegin()
17799 
      if ftype == TType.STOP:
17800 
        break
17801 
      if fid == 0:
17802 
        if ftype == TType.BOOL:
17803 
          self.success = iprot.readBool();
17804 
        else:
17805 
          iprot.skip(ftype)
17806 
      elif fid == 1:
17807 
        if ftype == TType.STRUCT:
17808 
          self.ex = TransactionServiceException()
17809 
          self.ex.read(iprot)
17810 
        else:
17811 
          iprot.skip(ftype)
17812 
      else:
17813 
        iprot.skip(ftype)
17814 
      iprot.readFieldEnd()
17815 
    iprot.readStructEnd()
17816 
 
17817 
  def write(self, oprot):
17818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17820 
      return
17821 
    oprot.writeStructBegin('validateReturnProduct_result')
17822 
    if self.success is not None:
17823 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17824 
      oprot.writeBool(self.success)
17825 
      oprot.writeFieldEnd()
17826 
    if self.ex is not None:
17827 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17828 
      self.ex.write(oprot)
17829 
      oprot.writeFieldEnd()
17830 
    oprot.writeFieldStop()
17831 
    oprot.writeStructEnd()
17832 
 
17833 
  def validate(self):
17834 
    return
17835 
 
17836 
 
17837 
  def __repr__(self):
17838 
    L = ['%s=%r' % (key, value)
17839 
      for key, value in self.__dict__.iteritems()]
17840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17841 
 
17842 
  def __eq__(self, other):
17843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17844 
 
17845 
  def __ne__(self, other):
17846 
    return not (self == other)
17847 
 
2616 chandransh 17848 
class reshipOrder_args:
17849 
  """
17850 
  Attributes:
17851 
   - orderId
17852 
  """
2591 chandransh 17853 
 
2616 chandransh 17854 
  thrift_spec = (
17855 
    None, # 0
17856 
    (1, TType.I64, 'orderId', None, None, ), # 1
17857 
  )
17858 
 
17859 
  def __init__(self, orderId=None,):
17860 
    self.orderId = orderId
17861 
 
17862 
  def read(self, iprot):
17863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17865 
      return
17866 
    iprot.readStructBegin()
17867 
    while True:
17868 
      (fname, ftype, fid) = iprot.readFieldBegin()
17869 
      if ftype == TType.STOP:
17870 
        break
17871 
      if fid == 1:
17872 
        if ftype == TType.I64:
17873 
          self.orderId = iprot.readI64();
17874 
        else:
17875 
          iprot.skip(ftype)
17876 
      else:
17877 
        iprot.skip(ftype)
17878 
      iprot.readFieldEnd()
17879 
    iprot.readStructEnd()
17880 
 
17881 
  def write(self, oprot):
17882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17884 
      return
17885 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17886 
    if self.orderId is not None:
2616 chandransh 17887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17888 
      oprot.writeI64(self.orderId)
17889 
      oprot.writeFieldEnd()
17890 
    oprot.writeFieldStop()
17891 
    oprot.writeStructEnd()
17892 
 
3431 rajveer 17893 
  def validate(self):
17894 
    return
17895 
 
17896 
 
2616 chandransh 17897 
  def __repr__(self):
17898 
    L = ['%s=%r' % (key, value)
17899 
      for key, value in self.__dict__.iteritems()]
17900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17901 
 
17902 
  def __eq__(self, other):
17903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17904 
 
17905 
  def __ne__(self, other):
17906 
    return not (self == other)
17907 
 
17908 
class reshipOrder_result:
17909 
  """
17910 
  Attributes:
17911 
   - success
17912 
   - ex
17913 
  """
17914 
 
17915 
  thrift_spec = (
17916 
    (0, TType.I64, 'success', None, None, ), # 0
17917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17918 
  )
17919 
 
17920 
  def __init__(self, success=None, ex=None,):
17921 
    self.success = success
17922 
    self.ex = ex
17923 
 
17924 
  def read(self, iprot):
17925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17927 
      return
17928 
    iprot.readStructBegin()
17929 
    while True:
17930 
      (fname, ftype, fid) = iprot.readFieldBegin()
17931 
      if ftype == TType.STOP:
17932 
        break
17933 
      if fid == 0:
17934 
        if ftype == TType.I64:
17935 
          self.success = iprot.readI64();
17936 
        else:
17937 
          iprot.skip(ftype)
17938 
      elif fid == 1:
17939 
        if ftype == TType.STRUCT:
17940 
          self.ex = TransactionServiceException()
17941 
          self.ex.read(iprot)
17942 
        else:
17943 
          iprot.skip(ftype)
17944 
      else:
17945 
        iprot.skip(ftype)
17946 
      iprot.readFieldEnd()
17947 
    iprot.readStructEnd()
17948 
 
17949 
  def write(self, oprot):
17950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17952 
      return
17953 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17954 
    if self.success is not None:
2616 chandransh 17955 
      oprot.writeFieldBegin('success', TType.I64, 0)
17956 
      oprot.writeI64(self.success)
17957 
      oprot.writeFieldEnd()
3431 rajveer 17958 
    if self.ex is not None:
2616 chandransh 17959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17960 
      self.ex.write(oprot)
17961 
      oprot.writeFieldEnd()
17962 
    oprot.writeFieldStop()
17963 
    oprot.writeStructEnd()
17964 
 
3431 rajveer 17965 
  def validate(self):
17966 
    return
17967 
 
17968 
 
2616 chandransh 17969 
  def __repr__(self):
17970 
    L = ['%s=%r' % (key, value)
17971 
      for key, value in self.__dict__.iteritems()]
17972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17973 
 
17974 
  def __eq__(self, other):
17975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17976 
 
17977 
  def __ne__(self, other):
17978 
    return not (self == other)
17979 
 
17980 
class refundOrder_args:
17981 
  """
17982 
  Attributes:
17983 
   - orderId
3226 chandransh 17984 
   - refundedBy
17985 
   - reason
2616 chandransh 17986 
  """
17987 
 
17988 
  thrift_spec = (
17989 
    None, # 0
17990 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17991 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17992 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17993 
  )
17994 
 
3226 chandransh 17995 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17996 
    self.orderId = orderId
3226 chandransh 17997 
    self.refundedBy = refundedBy
17998 
    self.reason = reason
2616 chandransh 17999 
 
18000 
  def read(self, iprot):
18001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18003 
      return
18004 
    iprot.readStructBegin()
18005 
    while True:
18006 
      (fname, ftype, fid) = iprot.readFieldBegin()
18007 
      if ftype == TType.STOP:
18008 
        break
18009 
      if fid == 1:
18010 
        if ftype == TType.I64:
18011 
          self.orderId = iprot.readI64();
18012 
        else:
18013 
          iprot.skip(ftype)
3226 chandransh 18014 
      elif fid == 2:
18015 
        if ftype == TType.STRING:
18016 
          self.refundedBy = iprot.readString();
18017 
        else:
18018 
          iprot.skip(ftype)
18019 
      elif fid == 3:
18020 
        if ftype == TType.STRING:
18021 
          self.reason = iprot.readString();
18022 
        else:
18023 
          iprot.skip(ftype)
2616 chandransh 18024 
      else:
18025 
        iprot.skip(ftype)
18026 
      iprot.readFieldEnd()
18027 
    iprot.readStructEnd()
18028 
 
18029 
  def write(self, oprot):
18030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18032 
      return
18033 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18034 
    if self.orderId is not None:
2616 chandransh 18035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18036 
      oprot.writeI64(self.orderId)
18037 
      oprot.writeFieldEnd()
3431 rajveer 18038 
    if self.refundedBy is not None:
3226 chandransh 18039 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18040 
      oprot.writeString(self.refundedBy)
18041 
      oprot.writeFieldEnd()
3431 rajveer 18042 
    if self.reason is not None:
3226 chandransh 18043 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18044 
      oprot.writeString(self.reason)
18045 
      oprot.writeFieldEnd()
2616 chandransh 18046 
    oprot.writeFieldStop()
18047 
    oprot.writeStructEnd()
18048 
 
3431 rajveer 18049 
  def validate(self):
18050 
    return
18051 
 
18052 
 
2616 chandransh 18053 
  def __repr__(self):
18054 
    L = ['%s=%r' % (key, value)
18055 
      for key, value in self.__dict__.iteritems()]
18056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18057 
 
18058 
  def __eq__(self, other):
18059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18060 
 
18061 
  def __ne__(self, other):
18062 
    return not (self == other)
18063 
 
18064 
class refundOrder_result:
18065 
  """
18066 
  Attributes:
18067 
   - success
18068 
   - ex
18069 
  """
18070 
 
18071 
  thrift_spec = (
18072 
    (0, TType.BOOL, 'success', None, None, ), # 0
18073 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18074 
  )
18075 
 
18076 
  def __init__(self, success=None, ex=None,):
18077 
    self.success = success
18078 
    self.ex = ex
18079 
 
18080 
  def read(self, iprot):
18081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18083 
      return
18084 
    iprot.readStructBegin()
18085 
    while True:
18086 
      (fname, ftype, fid) = iprot.readFieldBegin()
18087 
      if ftype == TType.STOP:
18088 
        break
18089 
      if fid == 0:
18090 
        if ftype == TType.BOOL:
18091 
          self.success = iprot.readBool();
18092 
        else:
18093 
          iprot.skip(ftype)
18094 
      elif fid == 1:
18095 
        if ftype == TType.STRUCT:
18096 
          self.ex = TransactionServiceException()
18097 
          self.ex.read(iprot)
18098 
        else:
18099 
          iprot.skip(ftype)
18100 
      else:
18101 
        iprot.skip(ftype)
18102 
      iprot.readFieldEnd()
18103 
    iprot.readStructEnd()
18104 
 
18105 
  def write(self, oprot):
18106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18108 
      return
18109 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18110 
    if self.success is not None:
2616 chandransh 18111 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18112 
      oprot.writeBool(self.success)
18113 
      oprot.writeFieldEnd()
3431 rajveer 18114 
    if self.ex is not None:
2616 chandransh 18115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18116 
      self.ex.write(oprot)
18117 
      oprot.writeFieldEnd()
18118 
    oprot.writeFieldStop()
18119 
    oprot.writeStructEnd()
18120 
 
3431 rajveer 18121 
  def validate(self):
18122 
    return
18123 
 
18124 
 
2616 chandransh 18125 
  def __repr__(self):
18126 
    L = ['%s=%r' % (key, value)
18127 
      for key, value in self.__dict__.iteritems()]
18128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18129 
 
18130 
  def __eq__(self, other):
18131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18132 
 
18133 
  def __ne__(self, other):
18134 
    return not (self == other)
18135 
 
2690 chandransh 18136 
class getReturnOrders_args:
18137 
  """
18138 
  Attributes:
18139 
   - warehouseId
18140 
   - fromDate
18141 
   - toDate
18142 
  """
2616 chandransh 18143 
 
2690 chandransh 18144 
  thrift_spec = (
18145 
    None, # 0
18146 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18147 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18148 
    (3, TType.I64, 'toDate', None, None, ), # 3
18149 
  )
18150 
 
18151 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18152 
    self.warehouseId = warehouseId
18153 
    self.fromDate = fromDate
18154 
    self.toDate = toDate
18155 
 
18156 
  def read(self, iprot):
18157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18159 
      return
18160 
    iprot.readStructBegin()
18161 
    while True:
18162 
      (fname, ftype, fid) = iprot.readFieldBegin()
18163 
      if ftype == TType.STOP:
18164 
        break
18165 
      if fid == 1:
18166 
        if ftype == TType.I64:
18167 
          self.warehouseId = iprot.readI64();
18168 
        else:
18169 
          iprot.skip(ftype)
18170 
      elif fid == 2:
18171 
        if ftype == TType.I64:
18172 
          self.fromDate = iprot.readI64();
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      elif fid == 3:
18176 
        if ftype == TType.I64:
18177 
          self.toDate = iprot.readI64();
18178 
        else:
18179 
          iprot.skip(ftype)
18180 
      else:
18181 
        iprot.skip(ftype)
18182 
      iprot.readFieldEnd()
18183 
    iprot.readStructEnd()
18184 
 
18185 
  def write(self, oprot):
18186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18188 
      return
18189 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18190 
    if self.warehouseId is not None:
2690 chandransh 18191 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18192 
      oprot.writeI64(self.warehouseId)
18193 
      oprot.writeFieldEnd()
3431 rajveer 18194 
    if self.fromDate is not None:
2690 chandransh 18195 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18196 
      oprot.writeI64(self.fromDate)
18197 
      oprot.writeFieldEnd()
3431 rajveer 18198 
    if self.toDate is not None:
2690 chandransh 18199 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18200 
      oprot.writeI64(self.toDate)
18201 
      oprot.writeFieldEnd()
18202 
    oprot.writeFieldStop()
18203 
    oprot.writeStructEnd()
18204 
 
3431 rajveer 18205 
  def validate(self):
18206 
    return
18207 
 
18208 
 
2690 chandransh 18209 
  def __repr__(self):
18210 
    L = ['%s=%r' % (key, value)
18211 
      for key, value in self.__dict__.iteritems()]
18212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18213 
 
18214 
  def __eq__(self, other):
18215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18216 
 
18217 
  def __ne__(self, other):
18218 
    return not (self == other)
18219 
 
18220 
class getReturnOrders_result:
18221 
  """
18222 
  Attributes:
18223 
   - success
18224 
  """
18225 
 
18226 
  thrift_spec = (
18227 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18228 
  )
18229 
 
18230 
  def __init__(self, success=None,):
18231 
    self.success = success
18232 
 
18233 
  def read(self, iprot):
18234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18236 
      return
18237 
    iprot.readStructBegin()
18238 
    while True:
18239 
      (fname, ftype, fid) = iprot.readFieldBegin()
18240 
      if ftype == TType.STOP:
18241 
        break
18242 
      if fid == 0:
18243 
        if ftype == TType.LIST:
18244 
          self.success = []
6031 rajveer 18245 
          (_etype399, _size396) = iprot.readListBegin()
18246 
          for _i400 in xrange(_size396):
18247 
            _elem401 = ReturnOrder()
18248 
            _elem401.read(iprot)
18249 
            self.success.append(_elem401)
2690 chandransh 18250 
          iprot.readListEnd()
18251 
        else:
18252 
          iprot.skip(ftype)
18253 
      else:
18254 
        iprot.skip(ftype)
18255 
      iprot.readFieldEnd()
18256 
    iprot.readStructEnd()
18257 
 
18258 
  def write(self, oprot):
18259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18261 
      return
18262 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18263 
    if self.success is not None:
2690 chandransh 18264 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18265 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18266 
      for iter402 in self.success:
18267 
        iter402.write(oprot)
2690 chandransh 18268 
      oprot.writeListEnd()
18269 
      oprot.writeFieldEnd()
18270 
    oprot.writeFieldStop()
18271 
    oprot.writeStructEnd()
18272 
 
3431 rajveer 18273 
  def validate(self):
18274 
    return
18275 
 
18276 
 
2690 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 
 
5481 phani.kuma 18288 
class getAllReturnOrders_args:
18289 
  """
18290 
  Attributes:
18291 
   - onlyNotProcessed
18292 
   - fromDate
18293 
   - toDate
18294 
  """
18295 
 
18296 
  thrift_spec = (
18297 
    None, # 0
18298 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18299 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18300 
    (3, TType.I64, 'toDate', None, None, ), # 3
18301 
  )
18302 
 
18303 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18304 
    self.onlyNotProcessed = onlyNotProcessed
18305 
    self.fromDate = fromDate
18306 
    self.toDate = toDate
18307 
 
18308 
  def read(self, iprot):
18309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18311 
      return
18312 
    iprot.readStructBegin()
18313 
    while True:
18314 
      (fname, ftype, fid) = iprot.readFieldBegin()
18315 
      if ftype == TType.STOP:
18316 
        break
18317 
      if fid == 1:
18318 
        if ftype == TType.BOOL:
18319 
          self.onlyNotProcessed = iprot.readBool();
18320 
        else:
18321 
          iprot.skip(ftype)
18322 
      elif fid == 2:
18323 
        if ftype == TType.I64:
18324 
          self.fromDate = iprot.readI64();
18325 
        else:
18326 
          iprot.skip(ftype)
18327 
      elif fid == 3:
18328 
        if ftype == TType.I64:
18329 
          self.toDate = iprot.readI64();
18330 
        else:
18331 
          iprot.skip(ftype)
18332 
      else:
18333 
        iprot.skip(ftype)
18334 
      iprot.readFieldEnd()
18335 
    iprot.readStructEnd()
18336 
 
18337 
  def write(self, oprot):
18338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18340 
      return
18341 
    oprot.writeStructBegin('getAllReturnOrders_args')
18342 
    if self.onlyNotProcessed is not None:
18343 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18344 
      oprot.writeBool(self.onlyNotProcessed)
18345 
      oprot.writeFieldEnd()
18346 
    if self.fromDate is not None:
18347 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18348 
      oprot.writeI64(self.fromDate)
18349 
      oprot.writeFieldEnd()
18350 
    if self.toDate is not None:
18351 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18352 
      oprot.writeI64(self.toDate)
18353 
      oprot.writeFieldEnd()
18354 
    oprot.writeFieldStop()
18355 
    oprot.writeStructEnd()
18356 
 
18357 
  def validate(self):
18358 
    return
18359 
 
18360 
 
18361 
  def __repr__(self):
18362 
    L = ['%s=%r' % (key, value)
18363 
      for key, value in self.__dict__.iteritems()]
18364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18365 
 
18366 
  def __eq__(self, other):
18367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18368 
 
18369 
  def __ne__(self, other):
18370 
    return not (self == other)
18371 
 
18372 
class getAllReturnOrders_result:
18373 
  """
18374 
  Attributes:
18375 
   - success
18376 
  """
18377 
 
18378 
  thrift_spec = (
18379 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18380 
  )
18381 
 
18382 
  def __init__(self, success=None,):
18383 
    self.success = success
18384 
 
18385 
  def read(self, iprot):
18386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18388 
      return
18389 
    iprot.readStructBegin()
18390 
    while True:
18391 
      (fname, ftype, fid) = iprot.readFieldBegin()
18392 
      if ftype == TType.STOP:
18393 
        break
18394 
      if fid == 0:
18395 
        if ftype == TType.LIST:
18396 
          self.success = []
6031 rajveer 18397 
          (_etype406, _size403) = iprot.readListBegin()
18398 
          for _i407 in xrange(_size403):
18399 
            _elem408 = ReturnOrder()
18400 
            _elem408.read(iprot)
18401 
            self.success.append(_elem408)
5481 phani.kuma 18402 
          iprot.readListEnd()
18403 
        else:
18404 
          iprot.skip(ftype)
18405 
      else:
18406 
        iprot.skip(ftype)
18407 
      iprot.readFieldEnd()
18408 
    iprot.readStructEnd()
18409 
 
18410 
  def write(self, oprot):
18411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18413 
      return
18414 
    oprot.writeStructBegin('getAllReturnOrders_result')
18415 
    if self.success is not None:
18416 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18417 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18418 
      for iter409 in self.success:
18419 
        iter409.write(oprot)
5481 phani.kuma 18420 
      oprot.writeListEnd()
18421 
      oprot.writeFieldEnd()
18422 
    oprot.writeFieldStop()
18423 
    oprot.writeStructEnd()
18424 
 
18425 
  def validate(self):
18426 
    return
18427 
 
18428 
 
18429 
  def __repr__(self):
18430 
    L = ['%s=%r' % (key, value)
18431 
      for key, value in self.__dict__.iteritems()]
18432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18433 
 
18434 
  def __eq__(self, other):
18435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18436 
 
18437 
  def __ne__(self, other):
18438 
    return not (self == other)
18439 
 
2700 chandransh 18440 
class getReturnOrder_args:
18441 
  """
18442 
  Attributes:
18443 
   - id
18444 
  """
18445 
 
18446 
  thrift_spec = (
18447 
    None, # 0
18448 
    (1, TType.I64, 'id', None, None, ), # 1
18449 
  )
18450 
 
18451 
  def __init__(self, id=None,):
18452 
    self.id = id
18453 
 
18454 
  def read(self, iprot):
18455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18457 
      return
18458 
    iprot.readStructBegin()
18459 
    while True:
18460 
      (fname, ftype, fid) = iprot.readFieldBegin()
18461 
      if ftype == TType.STOP:
18462 
        break
18463 
      if fid == 1:
18464 
        if ftype == TType.I64:
18465 
          self.id = iprot.readI64();
18466 
        else:
18467 
          iprot.skip(ftype)
18468 
      else:
18469 
        iprot.skip(ftype)
18470 
      iprot.readFieldEnd()
18471 
    iprot.readStructEnd()
18472 
 
18473 
  def write(self, oprot):
18474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18476 
      return
18477 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18478 
    if self.id is not None:
2700 chandransh 18479 
      oprot.writeFieldBegin('id', TType.I64, 1)
18480 
      oprot.writeI64(self.id)
18481 
      oprot.writeFieldEnd()
18482 
    oprot.writeFieldStop()
18483 
    oprot.writeStructEnd()
18484 
 
3431 rajveer 18485 
  def validate(self):
18486 
    return
18487 
 
18488 
 
2700 chandransh 18489 
  def __repr__(self):
18490 
    L = ['%s=%r' % (key, value)
18491 
      for key, value in self.__dict__.iteritems()]
18492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18493 
 
18494 
  def __eq__(self, other):
18495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18496 
 
18497 
  def __ne__(self, other):
18498 
    return not (self == other)
18499 
 
18500 
class getReturnOrder_result:
18501 
  """
18502 
  Attributes:
18503 
   - success
18504 
   - ex
18505 
  """
18506 
 
18507 
  thrift_spec = (
18508 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18510 
  )
18511 
 
18512 
  def __init__(self, success=None, ex=None,):
18513 
    self.success = success
18514 
    self.ex = ex
18515 
 
18516 
  def read(self, iprot):
18517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18519 
      return
18520 
    iprot.readStructBegin()
18521 
    while True:
18522 
      (fname, ftype, fid) = iprot.readFieldBegin()
18523 
      if ftype == TType.STOP:
18524 
        break
18525 
      if fid == 0:
18526 
        if ftype == TType.STRUCT:
18527 
          self.success = ReturnOrder()
18528 
          self.success.read(iprot)
18529 
        else:
18530 
          iprot.skip(ftype)
18531 
      elif fid == 1:
18532 
        if ftype == TType.STRUCT:
18533 
          self.ex = TransactionServiceException()
18534 
          self.ex.read(iprot)
18535 
        else:
18536 
          iprot.skip(ftype)
18537 
      else:
18538 
        iprot.skip(ftype)
18539 
      iprot.readFieldEnd()
18540 
    iprot.readStructEnd()
18541 
 
18542 
  def write(self, oprot):
18543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18545 
      return
18546 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18547 
    if self.success is not None:
2700 chandransh 18548 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18549 
      self.success.write(oprot)
18550 
      oprot.writeFieldEnd()
3431 rajveer 18551 
    if self.ex is not None:
2700 chandransh 18552 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18553 
      self.ex.write(oprot)
18554 
      oprot.writeFieldEnd()
18555 
    oprot.writeFieldStop()
18556 
    oprot.writeStructEnd()
18557 
 
3431 rajveer 18558 
  def validate(self):
18559 
    return
18560 
 
18561 
 
2700 chandransh 18562 
  def __repr__(self):
18563 
    L = ['%s=%r' % (key, value)
18564 
      for key, value in self.__dict__.iteritems()]
18565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18566 
 
18567 
  def __eq__(self, other):
18568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18569 
 
18570 
  def __ne__(self, other):
18571 
    return not (self == other)
18572 
 
2690 chandransh 18573 
class processReturn_args:
18574 
  """
18575 
  Attributes:
18576 
   - returnOrderId
18577 
  """
18578 
 
18579 
  thrift_spec = (
18580 
    None, # 0
18581 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18582 
  )
18583 
 
18584 
  def __init__(self, returnOrderId=None,):
18585 
    self.returnOrderId = returnOrderId
18586 
 
18587 
  def read(self, iprot):
18588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18590 
      return
18591 
    iprot.readStructBegin()
18592 
    while True:
18593 
      (fname, ftype, fid) = iprot.readFieldBegin()
18594 
      if ftype == TType.STOP:
18595 
        break
18596 
      if fid == 1:
18597 
        if ftype == TType.I64:
18598 
          self.returnOrderId = iprot.readI64();
18599 
        else:
18600 
          iprot.skip(ftype)
18601 
      else:
18602 
        iprot.skip(ftype)
18603 
      iprot.readFieldEnd()
18604 
    iprot.readStructEnd()
18605 
 
18606 
  def write(self, oprot):
18607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18609 
      return
18610 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18611 
    if self.returnOrderId is not None:
2690 chandransh 18612 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18613 
      oprot.writeI64(self.returnOrderId)
18614 
      oprot.writeFieldEnd()
18615 
    oprot.writeFieldStop()
18616 
    oprot.writeStructEnd()
18617 
 
3431 rajveer 18618 
  def validate(self):
18619 
    return
18620 
 
18621 
 
2690 chandransh 18622 
  def __repr__(self):
18623 
    L = ['%s=%r' % (key, value)
18624 
      for key, value in self.__dict__.iteritems()]
18625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18626 
 
18627 
  def __eq__(self, other):
18628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18629 
 
18630 
  def __ne__(self, other):
18631 
    return not (self == other)
18632 
 
18633 
class processReturn_result:
18634 
  """
18635 
  Attributes:
18636 
   - ex
18637 
  """
18638 
 
18639 
  thrift_spec = (
18640 
    None, # 0
18641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18642 
  )
18643 
 
18644 
  def __init__(self, ex=None,):
18645 
    self.ex = ex
18646 
 
18647 
  def read(self, iprot):
18648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18650 
      return
18651 
    iprot.readStructBegin()
18652 
    while True:
18653 
      (fname, ftype, fid) = iprot.readFieldBegin()
18654 
      if ftype == TType.STOP:
18655 
        break
18656 
      if fid == 1:
18657 
        if ftype == TType.STRUCT:
18658 
          self.ex = TransactionServiceException()
18659 
          self.ex.read(iprot)
18660 
        else:
18661 
          iprot.skip(ftype)
18662 
      else:
18663 
        iprot.skip(ftype)
18664 
      iprot.readFieldEnd()
18665 
    iprot.readStructEnd()
18666 
 
18667 
  def write(self, oprot):
18668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18670 
      return
18671 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18672 
    if self.ex is not None:
2690 chandransh 18673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18674 
      self.ex.write(oprot)
18675 
      oprot.writeFieldEnd()
18676 
    oprot.writeFieldStop()
18677 
    oprot.writeStructEnd()
18678 
 
3431 rajveer 18679 
  def validate(self):
18680 
    return
18681 
 
18682 
 
2690 chandransh 18683 
  def __repr__(self):
18684 
    L = ['%s=%r' % (key, value)
18685 
      for key, value in self.__dict__.iteritems()]
18686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18687 
 
18688 
  def __eq__(self, other):
18689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18690 
 
18691 
  def __ne__(self, other):
18692 
    return not (self == other)
18693 
 
3451 chandransh 18694 
class updateWeight_args:
18695 
  """
18696 
  Attributes:
18697 
   - orderId
18698 
   - weight
18699 
  """
18700 
 
18701 
  thrift_spec = (
18702 
    None, # 0
18703 
    (1, TType.I64, 'orderId', None, None, ), # 1
18704 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18705 
  )
18706 
 
18707 
  def __init__(self, orderId=None, weight=None,):
18708 
    self.orderId = orderId
18709 
    self.weight = weight
18710 
 
18711 
  def read(self, iprot):
18712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18714 
      return
18715 
    iprot.readStructBegin()
18716 
    while True:
18717 
      (fname, ftype, fid) = iprot.readFieldBegin()
18718 
      if ftype == TType.STOP:
18719 
        break
18720 
      if fid == 1:
18721 
        if ftype == TType.I64:
18722 
          self.orderId = iprot.readI64();
18723 
        else:
18724 
          iprot.skip(ftype)
18725 
      elif fid == 2:
18726 
        if ftype == TType.DOUBLE:
18727 
          self.weight = iprot.readDouble();
18728 
        else:
18729 
          iprot.skip(ftype)
18730 
      else:
18731 
        iprot.skip(ftype)
18732 
      iprot.readFieldEnd()
18733 
    iprot.readStructEnd()
18734 
 
18735 
  def write(self, oprot):
18736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18738 
      return
18739 
    oprot.writeStructBegin('updateWeight_args')
18740 
    if self.orderId is not None:
18741 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18742 
      oprot.writeI64(self.orderId)
18743 
      oprot.writeFieldEnd()
18744 
    if self.weight is not None:
18745 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18746 
      oprot.writeDouble(self.weight)
18747 
      oprot.writeFieldEnd()
18748 
    oprot.writeFieldStop()
18749 
    oprot.writeStructEnd()
18750 
 
18751 
  def validate(self):
18752 
    return
18753 
 
18754 
 
18755 
  def __repr__(self):
18756 
    L = ['%s=%r' % (key, value)
18757 
      for key, value in self.__dict__.iteritems()]
18758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18759 
 
18760 
  def __eq__(self, other):
18761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18762 
 
18763 
  def __ne__(self, other):
18764 
    return not (self == other)
18765 
 
18766 
class updateWeight_result:
18767 
  """
18768 
  Attributes:
18769 
   - success
18770 
   - ex
18771 
  """
18772 
 
18773 
  thrift_spec = (
18774 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18776 
  )
18777 
 
18778 
  def __init__(self, success=None, ex=None,):
18779 
    self.success = success
18780 
    self.ex = ex
18781 
 
18782 
  def read(self, iprot):
18783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18785 
      return
18786 
    iprot.readStructBegin()
18787 
    while True:
18788 
      (fname, ftype, fid) = iprot.readFieldBegin()
18789 
      if ftype == TType.STOP:
18790 
        break
18791 
      if fid == 0:
18792 
        if ftype == TType.STRUCT:
18793 
          self.success = Order()
18794 
          self.success.read(iprot)
18795 
        else:
18796 
          iprot.skip(ftype)
18797 
      elif fid == 1:
18798 
        if ftype == TType.STRUCT:
18799 
          self.ex = TransactionServiceException()
18800 
          self.ex.read(iprot)
18801 
        else:
18802 
          iprot.skip(ftype)
18803 
      else:
18804 
        iprot.skip(ftype)
18805 
      iprot.readFieldEnd()
18806 
    iprot.readStructEnd()
18807 
 
18808 
  def write(self, oprot):
18809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18811 
      return
18812 
    oprot.writeStructBegin('updateWeight_result')
18813 
    if self.success is not None:
18814 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18815 
      self.success.write(oprot)
18816 
      oprot.writeFieldEnd()
18817 
    if self.ex is not None:
18818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18819 
      self.ex.write(oprot)
18820 
      oprot.writeFieldEnd()
18821 
    oprot.writeFieldStop()
18822 
    oprot.writeStructEnd()
18823 
 
18824 
  def validate(self):
18825 
    return
18826 
 
18827 
 
18828 
  def __repr__(self):
18829 
    L = ['%s=%r' % (key, value)
18830 
      for key, value in self.__dict__.iteritems()]
18831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18832 
 
18833 
  def __eq__(self, other):
18834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18835 
 
18836 
  def __ne__(self, other):
18837 
    return not (self == other)
3469 chandransh 18838 
 
18839 
class changeItem_args:
18840 
  """
18841 
  Attributes:
18842 
   - orderId
18843 
   - itemId
18844 
  """
18845 
 
18846 
  thrift_spec = (
18847 
    None, # 0
18848 
    (1, TType.I64, 'orderId', None, None, ), # 1
18849 
    (2, TType.I64, 'itemId', None, None, ), # 2
18850 
  )
18851 
 
18852 
  def __init__(self, orderId=None, itemId=None,):
18853 
    self.orderId = orderId
18854 
    self.itemId = itemId
18855 
 
18856 
  def read(self, iprot):
18857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18859 
      return
18860 
    iprot.readStructBegin()
18861 
    while True:
18862 
      (fname, ftype, fid) = iprot.readFieldBegin()
18863 
      if ftype == TType.STOP:
18864 
        break
18865 
      if fid == 1:
18866 
        if ftype == TType.I64:
18867 
          self.orderId = iprot.readI64();
18868 
        else:
18869 
          iprot.skip(ftype)
18870 
      elif fid == 2:
18871 
        if ftype == TType.I64:
18872 
          self.itemId = iprot.readI64();
18873 
        else:
18874 
          iprot.skip(ftype)
18875 
      else:
18876 
        iprot.skip(ftype)
18877 
      iprot.readFieldEnd()
18878 
    iprot.readStructEnd()
18879 
 
18880 
  def write(self, oprot):
18881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18883 
      return
18884 
    oprot.writeStructBegin('changeItem_args')
18885 
    if self.orderId is not None:
18886 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18887 
      oprot.writeI64(self.orderId)
18888 
      oprot.writeFieldEnd()
18889 
    if self.itemId is not None:
18890 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18891 
      oprot.writeI64(self.itemId)
18892 
      oprot.writeFieldEnd()
18893 
    oprot.writeFieldStop()
18894 
    oprot.writeStructEnd()
18895 
 
18896 
  def validate(self):
18897 
    return
18898 
 
18899 
 
18900 
  def __repr__(self):
18901 
    L = ['%s=%r' % (key, value)
18902 
      for key, value in self.__dict__.iteritems()]
18903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18904 
 
18905 
  def __eq__(self, other):
18906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18907 
 
18908 
  def __ne__(self, other):
18909 
    return not (self == other)
18910 
 
18911 
class changeItem_result:
18912 
  """
18913 
  Attributes:
18914 
   - success
18915 
   - ex
18916 
  """
18917 
 
18918 
  thrift_spec = (
18919 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18920 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18921 
  )
18922 
 
18923 
  def __init__(self, success=None, ex=None,):
18924 
    self.success = success
18925 
    self.ex = ex
18926 
 
18927 
  def read(self, iprot):
18928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18930 
      return
18931 
    iprot.readStructBegin()
18932 
    while True:
18933 
      (fname, ftype, fid) = iprot.readFieldBegin()
18934 
      if ftype == TType.STOP:
18935 
        break
18936 
      if fid == 0:
18937 
        if ftype == TType.STRUCT:
18938 
          self.success = Order()
18939 
          self.success.read(iprot)
18940 
        else:
18941 
          iprot.skip(ftype)
18942 
      elif fid == 1:
18943 
        if ftype == TType.STRUCT:
18944 
          self.ex = TransactionServiceException()
18945 
          self.ex.read(iprot)
18946 
        else:
18947 
          iprot.skip(ftype)
18948 
      else:
18949 
        iprot.skip(ftype)
18950 
      iprot.readFieldEnd()
18951 
    iprot.readStructEnd()
18952 
 
18953 
  def write(self, oprot):
18954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18956 
      return
18957 
    oprot.writeStructBegin('changeItem_result')
18958 
    if self.success is not None:
18959 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18960 
      self.success.write(oprot)
18961 
      oprot.writeFieldEnd()
18962 
    if self.ex is not None:
18963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18964 
      self.ex.write(oprot)
18965 
      oprot.writeFieldEnd()
18966 
    oprot.writeFieldStop()
18967 
    oprot.writeStructEnd()
18968 
 
18969 
  def validate(self):
18970 
    return
18971 
 
18972 
 
18973 
  def __repr__(self):
18974 
    L = ['%s=%r' % (key, value)
18975 
      for key, value in self.__dict__.iteritems()]
18976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18977 
 
18978 
  def __eq__(self, other):
18979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18980 
 
18981 
  def __ne__(self, other):
18982 
    return not (self == other)
18983 
 
18984 
class shiftToWarehouse_args:
18985 
  """
18986 
  Attributes:
18987 
   - orderId
18988 
   - warehouseId
18989 
  """
18990 
 
18991 
  thrift_spec = (
18992 
    None, # 0
18993 
    (1, TType.I64, 'orderId', None, None, ), # 1
18994 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18995 
  )
18996 
 
18997 
  def __init__(self, orderId=None, warehouseId=None,):
18998 
    self.orderId = orderId
18999 
    self.warehouseId = warehouseId
19000 
 
19001 
  def read(self, iprot):
19002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19004 
      return
19005 
    iprot.readStructBegin()
19006 
    while True:
19007 
      (fname, ftype, fid) = iprot.readFieldBegin()
19008 
      if ftype == TType.STOP:
19009 
        break
19010 
      if fid == 1:
19011 
        if ftype == TType.I64:
19012 
          self.orderId = iprot.readI64();
19013 
        else:
19014 
          iprot.skip(ftype)
19015 
      elif fid == 2:
19016 
        if ftype == TType.I64:
19017 
          self.warehouseId = iprot.readI64();
19018 
        else:
19019 
          iprot.skip(ftype)
19020 
      else:
19021 
        iprot.skip(ftype)
19022 
      iprot.readFieldEnd()
19023 
    iprot.readStructEnd()
19024 
 
19025 
  def write(self, oprot):
19026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19028 
      return
19029 
    oprot.writeStructBegin('shiftToWarehouse_args')
19030 
    if self.orderId is not None:
19031 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19032 
      oprot.writeI64(self.orderId)
19033 
      oprot.writeFieldEnd()
19034 
    if self.warehouseId is not None:
19035 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19036 
      oprot.writeI64(self.warehouseId)
19037 
      oprot.writeFieldEnd()
19038 
    oprot.writeFieldStop()
19039 
    oprot.writeStructEnd()
19040 
 
19041 
  def validate(self):
19042 
    return
19043 
 
19044 
 
19045 
  def __repr__(self):
19046 
    L = ['%s=%r' % (key, value)
19047 
      for key, value in self.__dict__.iteritems()]
19048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19049 
 
19050 
  def __eq__(self, other):
19051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19052 
 
19053 
  def __ne__(self, other):
19054 
    return not (self == other)
19055 
 
19056 
class shiftToWarehouse_result:
19057 
  """
19058 
  Attributes:
19059 
   - success
19060 
   - ex
19061 
  """
19062 
 
19063 
  thrift_spec = (
19064 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19066 
  )
19067 
 
19068 
  def __init__(self, success=None, ex=None,):
19069 
    self.success = success
19070 
    self.ex = ex
19071 
 
19072 
  def read(self, iprot):
19073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19075 
      return
19076 
    iprot.readStructBegin()
19077 
    while True:
19078 
      (fname, ftype, fid) = iprot.readFieldBegin()
19079 
      if ftype == TType.STOP:
19080 
        break
19081 
      if fid == 0:
19082 
        if ftype == TType.STRUCT:
19083 
          self.success = Order()
19084 
          self.success.read(iprot)
19085 
        else:
19086 
          iprot.skip(ftype)
19087 
      elif fid == 1:
19088 
        if ftype == TType.STRUCT:
19089 
          self.ex = TransactionServiceException()
19090 
          self.ex.read(iprot)
19091 
        else:
19092 
          iprot.skip(ftype)
19093 
      else:
19094 
        iprot.skip(ftype)
19095 
      iprot.readFieldEnd()
19096 
    iprot.readStructEnd()
19097 
 
19098 
  def write(self, oprot):
19099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19101 
      return
19102 
    oprot.writeStructBegin('shiftToWarehouse_result')
19103 
    if self.success is not None:
19104 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19105 
      self.success.write(oprot)
19106 
      oprot.writeFieldEnd()
19107 
    if self.ex is not None:
19108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19109 
      self.ex.write(oprot)
19110 
      oprot.writeFieldEnd()
19111 
    oprot.writeFieldStop()
19112 
    oprot.writeStructEnd()
19113 
 
19114 
  def validate(self):
19115 
    return
19116 
 
19117 
 
19118 
  def __repr__(self):
19119 
    L = ['%s=%r' % (key, value)
19120 
      for key, value in self.__dict__.iteritems()]
19121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19122 
 
19123 
  def __eq__(self, other):
19124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19125 
 
19126 
  def __ne__(self, other):
19127 
    return not (self == other)
3553 chandransh 19128 
 
19129 
class addDelayReason_args:
19130 
  """
19131 
  Attributes:
19132 
   - orderId
19133 
   - delayReason
3986 chandransh 19134 
   - furtherDelay
4647 rajveer 19135 
   - delayReasonText
3553 chandransh 19136 
  """
19137 
 
19138 
  thrift_spec = (
19139 
    None, # 0
19140 
    (1, TType.I64, 'orderId', None, None, ), # 1
19141 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19142 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19143 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19144 
  )
19145 
 
4647 rajveer 19146 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19147 
    self.orderId = orderId
19148 
    self.delayReason = delayReason
3986 chandransh 19149 
    self.furtherDelay = furtherDelay
4647 rajveer 19150 
    self.delayReasonText = delayReasonText
3553 chandransh 19151 
 
19152 
  def read(self, iprot):
19153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19155 
      return
19156 
    iprot.readStructBegin()
19157 
    while True:
19158 
      (fname, ftype, fid) = iprot.readFieldBegin()
19159 
      if ftype == TType.STOP:
19160 
        break
19161 
      if fid == 1:
19162 
        if ftype == TType.I64:
19163 
          self.orderId = iprot.readI64();
19164 
        else:
19165 
          iprot.skip(ftype)
19166 
      elif fid == 2:
19167 
        if ftype == TType.I32:
19168 
          self.delayReason = iprot.readI32();
19169 
        else:
19170 
          iprot.skip(ftype)
3986 chandransh 19171 
      elif fid == 3:
19172 
        if ftype == TType.I64:
19173 
          self.furtherDelay = iprot.readI64();
19174 
        else:
19175 
          iprot.skip(ftype)
4647 rajveer 19176 
      elif fid == 4:
19177 
        if ftype == TType.STRING:
19178 
          self.delayReasonText = iprot.readString();
19179 
        else:
19180 
          iprot.skip(ftype)
3553 chandransh 19181 
      else:
19182 
        iprot.skip(ftype)
19183 
      iprot.readFieldEnd()
19184 
    iprot.readStructEnd()
19185 
 
19186 
  def write(self, oprot):
19187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19189 
      return
19190 
    oprot.writeStructBegin('addDelayReason_args')
19191 
    if self.orderId is not None:
19192 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19193 
      oprot.writeI64(self.orderId)
19194 
      oprot.writeFieldEnd()
19195 
    if self.delayReason is not None:
19196 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19197 
      oprot.writeI32(self.delayReason)
19198 
      oprot.writeFieldEnd()
3986 chandransh 19199 
    if self.furtherDelay is not None:
19200 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19201 
      oprot.writeI64(self.furtherDelay)
19202 
      oprot.writeFieldEnd()
4647 rajveer 19203 
    if self.delayReasonText is not None:
19204 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19205 
      oprot.writeString(self.delayReasonText)
19206 
      oprot.writeFieldEnd()
3553 chandransh 19207 
    oprot.writeFieldStop()
19208 
    oprot.writeStructEnd()
19209 
 
19210 
  def validate(self):
19211 
    return
19212 
 
19213 
 
19214 
  def __repr__(self):
19215 
    L = ['%s=%r' % (key, value)
19216 
      for key, value in self.__dict__.iteritems()]
19217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19218 
 
19219 
  def __eq__(self, other):
19220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19221 
 
19222 
  def __ne__(self, other):
19223 
    return not (self == other)
19224 
 
19225 
class addDelayReason_result:
19226 
  """
19227 
  Attributes:
19228 
   - success
19229 
   - ex
19230 
  """
19231 
 
19232 
  thrift_spec = (
19233 
    (0, TType.BOOL, 'success', None, None, ), # 0
19234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19235 
  )
19236 
 
19237 
  def __init__(self, success=None, ex=None,):
19238 
    self.success = success
19239 
    self.ex = ex
19240 
 
19241 
  def read(self, iprot):
19242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19244 
      return
19245 
    iprot.readStructBegin()
19246 
    while True:
19247 
      (fname, ftype, fid) = iprot.readFieldBegin()
19248 
      if ftype == TType.STOP:
19249 
        break
19250 
      if fid == 0:
19251 
        if ftype == TType.BOOL:
19252 
          self.success = iprot.readBool();
19253 
        else:
19254 
          iprot.skip(ftype)
19255 
      elif fid == 1:
19256 
        if ftype == TType.STRUCT:
19257 
          self.ex = TransactionServiceException()
19258 
          self.ex.read(iprot)
19259 
        else:
19260 
          iprot.skip(ftype)
19261 
      else:
19262 
        iprot.skip(ftype)
19263 
      iprot.readFieldEnd()
19264 
    iprot.readStructEnd()
19265 
 
19266 
  def write(self, oprot):
19267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19269 
      return
19270 
    oprot.writeStructBegin('addDelayReason_result')
19271 
    if self.success is not None:
19272 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19273 
      oprot.writeBool(self.success)
19274 
      oprot.writeFieldEnd()
19275 
    if self.ex is not None:
19276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19277 
      self.ex.write(oprot)
19278 
      oprot.writeFieldEnd()
19279 
    oprot.writeFieldStop()
19280 
    oprot.writeStructEnd()
19281 
 
19282 
  def validate(self):
19283 
    return
19284 
 
19285 
 
19286 
  def __repr__(self):
19287 
    L = ['%s=%r' % (key, value)
19288 
      for key, value in self.__dict__.iteritems()]
19289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19290 
 
19291 
  def __eq__(self, other):
19292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19293 
 
19294 
  def __ne__(self, other):
19295 
    return not (self == other)
3956 chandransh 19296 
 
19297 
class reconcileCodCollection_args:
19298 
  """
19299 
  Attributes:
19300 
   - collectedAmountMap
19301 
   - xferBy
19302 
   - xferTxnId
19303 
   - xferDate
19304 
  """
19305 
 
19306 
  thrift_spec = (
19307 
    None, # 0
19308 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19309 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19310 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19311 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19312 
  )
19313 
 
19314 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19315 
    self.collectedAmountMap = collectedAmountMap
19316 
    self.xferBy = xferBy
19317 
    self.xferTxnId = xferTxnId
19318 
    self.xferDate = xferDate
19319 
 
19320 
  def read(self, iprot):
19321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19323 
      return
19324 
    iprot.readStructBegin()
19325 
    while True:
19326 
      (fname, ftype, fid) = iprot.readFieldBegin()
19327 
      if ftype == TType.STOP:
19328 
        break
19329 
      if fid == 1:
19330 
        if ftype == TType.MAP:
19331 
          self.collectedAmountMap = {}
6031 rajveer 19332 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
19333 
          for _i414 in xrange(_size410):
19334 
            _key415 = iprot.readString();
19335 
            _val416 = iprot.readDouble();
19336 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 19337 
          iprot.readMapEnd()
19338 
        else:
19339 
          iprot.skip(ftype)
19340 
      elif fid == 2:
19341 
        if ftype == TType.STRING:
19342 
          self.xferBy = iprot.readString();
19343 
        else:
19344 
          iprot.skip(ftype)
19345 
      elif fid == 3:
19346 
        if ftype == TType.STRING:
19347 
          self.xferTxnId = iprot.readString();
19348 
        else:
19349 
          iprot.skip(ftype)
19350 
      elif fid == 4:
19351 
        if ftype == TType.I64:
19352 
          self.xferDate = iprot.readI64();
19353 
        else:
19354 
          iprot.skip(ftype)
19355 
      else:
19356 
        iprot.skip(ftype)
19357 
      iprot.readFieldEnd()
19358 
    iprot.readStructEnd()
19359 
 
19360 
  def write(self, oprot):
19361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19363 
      return
19364 
    oprot.writeStructBegin('reconcileCodCollection_args')
19365 
    if self.collectedAmountMap is not None:
19366 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19367 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6031 rajveer 19368 
      for kiter417,viter418 in self.collectedAmountMap.items():
19369 
        oprot.writeString(kiter417)
19370 
        oprot.writeDouble(viter418)
3956 chandransh 19371 
      oprot.writeMapEnd()
19372 
      oprot.writeFieldEnd()
19373 
    if self.xferBy is not None:
19374 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19375 
      oprot.writeString(self.xferBy)
19376 
      oprot.writeFieldEnd()
19377 
    if self.xferTxnId is not None:
19378 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19379 
      oprot.writeString(self.xferTxnId)
19380 
      oprot.writeFieldEnd()
19381 
    if self.xferDate is not None:
19382 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19383 
      oprot.writeI64(self.xferDate)
19384 
      oprot.writeFieldEnd()
19385 
    oprot.writeFieldStop()
19386 
    oprot.writeStructEnd()
19387 
 
19388 
  def validate(self):
19389 
    return
19390 
 
19391 
 
19392 
  def __repr__(self):
19393 
    L = ['%s=%r' % (key, value)
19394 
      for key, value in self.__dict__.iteritems()]
19395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19396 
 
19397 
  def __eq__(self, other):
19398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19399 
 
19400 
  def __ne__(self, other):
19401 
    return not (self == other)
19402 
 
19403 
class reconcileCodCollection_result:
19404 
  """
19405 
  Attributes:
19406 
   - success
19407 
   - ex
19408 
  """
19409 
 
19410 
  thrift_spec = (
19411 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19413 
  )
19414 
 
19415 
  def __init__(self, success=None, ex=None,):
19416 
    self.success = success
19417 
    self.ex = ex
19418 
 
19419 
  def read(self, iprot):
19420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19422 
      return
19423 
    iprot.readStructBegin()
19424 
    while True:
19425 
      (fname, ftype, fid) = iprot.readFieldBegin()
19426 
      if ftype == TType.STOP:
19427 
        break
19428 
      if fid == 0:
19429 
        if ftype == TType.MAP:
19430 
          self.success = {}
6031 rajveer 19431 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
19432 
          for _i423 in xrange(_size419):
19433 
            _key424 = iprot.readString();
19434 
            _val425 = iprot.readString();
19435 
            self.success[_key424] = _val425
3956 chandransh 19436 
          iprot.readMapEnd()
19437 
        else:
19438 
          iprot.skip(ftype)
19439 
      elif fid == 1:
19440 
        if ftype == TType.STRUCT:
19441 
          self.ex = TransactionServiceException()
19442 
          self.ex.read(iprot)
19443 
        else:
19444 
          iprot.skip(ftype)
19445 
      else:
19446 
        iprot.skip(ftype)
19447 
      iprot.readFieldEnd()
19448 
    iprot.readStructEnd()
19449 
 
19450 
  def write(self, oprot):
19451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19453 
      return
19454 
    oprot.writeStructBegin('reconcileCodCollection_result')
19455 
    if self.success is not None:
19456 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19457 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6031 rajveer 19458 
      for kiter426,viter427 in self.success.items():
19459 
        oprot.writeString(kiter426)
19460 
        oprot.writeString(viter427)
3956 chandransh 19461 
      oprot.writeMapEnd()
19462 
      oprot.writeFieldEnd()
19463 
    if self.ex is not None:
19464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19465 
      self.ex.write(oprot)
19466 
      oprot.writeFieldEnd()
19467 
    oprot.writeFieldStop()
19468 
    oprot.writeStructEnd()
19469 
 
19470 
  def validate(self):
19471 
    return
19472 
 
19473 
 
19474 
  def __repr__(self):
19475 
    L = ['%s=%r' % (key, value)
19476 
      for key, value in self.__dict__.iteritems()]
19477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19478 
 
19479 
  def __eq__(self, other):
19480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19481 
 
19482 
  def __ne__(self, other):
19483 
    return not (self == other)
4008 mandeep.dh 19484 
 
19485 
class getTransactionsRequiringExtraProcessing_args:
19486 
  """
19487 
  Attributes:
19488 
   - category
19489 
  """
19490 
 
19491 
  thrift_spec = (
19492 
    None, # 0
19493 
    (1, TType.I32, 'category', None, None, ), # 1
19494 
  )
19495 
 
19496 
  def __init__(self, category=None,):
19497 
    self.category = category
19498 
 
19499 
  def read(self, iprot):
19500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19502 
      return
19503 
    iprot.readStructBegin()
19504 
    while True:
19505 
      (fname, ftype, fid) = iprot.readFieldBegin()
19506 
      if ftype == TType.STOP:
19507 
        break
19508 
      if fid == 1:
19509 
        if ftype == TType.I32:
19510 
          self.category = iprot.readI32();
19511 
        else:
19512 
          iprot.skip(ftype)
19513 
      else:
19514 
        iprot.skip(ftype)
19515 
      iprot.readFieldEnd()
19516 
    iprot.readStructEnd()
19517 
 
19518 
  def write(self, oprot):
19519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19521 
      return
19522 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19523 
    if self.category is not None:
19524 
      oprot.writeFieldBegin('category', TType.I32, 1)
19525 
      oprot.writeI32(self.category)
19526 
      oprot.writeFieldEnd()
19527 
    oprot.writeFieldStop()
19528 
    oprot.writeStructEnd()
19529 
 
19530 
  def validate(self):
19531 
    return
19532 
 
19533 
 
19534 
  def __repr__(self):
19535 
    L = ['%s=%r' % (key, value)
19536 
      for key, value in self.__dict__.iteritems()]
19537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19538 
 
19539 
  def __eq__(self, other):
19540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19541 
 
19542 
  def __ne__(self, other):
19543 
    return not (self == other)
19544 
 
19545 
class getTransactionsRequiringExtraProcessing_result:
19546 
  """
19547 
  Attributes:
19548 
   - success
19549 
  """
19550 
 
19551 
  thrift_spec = (
19552 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19553 
  )
19554 
 
19555 
  def __init__(self, success=None,):
19556 
    self.success = success
19557 
 
19558 
  def read(self, iprot):
19559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19561 
      return
19562 
    iprot.readStructBegin()
19563 
    while True:
19564 
      (fname, ftype, fid) = iprot.readFieldBegin()
19565 
      if ftype == TType.STOP:
19566 
        break
19567 
      if fid == 0:
19568 
        if ftype == TType.LIST:
19569 
          self.success = []
6031 rajveer 19570 
          (_etype431, _size428) = iprot.readListBegin()
19571 
          for _i432 in xrange(_size428):
19572 
            _elem433 = iprot.readI64();
19573 
            self.success.append(_elem433)
4008 mandeep.dh 19574 
          iprot.readListEnd()
19575 
        else:
19576 
          iprot.skip(ftype)
19577 
      else:
19578 
        iprot.skip(ftype)
19579 
      iprot.readFieldEnd()
19580 
    iprot.readStructEnd()
19581 
 
19582 
  def write(self, oprot):
19583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19585 
      return
19586 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19587 
    if self.success is not None:
19588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19589 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 19590 
      for iter434 in self.success:
19591 
        oprot.writeI64(iter434)
4008 mandeep.dh 19592 
      oprot.writeListEnd()
19593 
      oprot.writeFieldEnd()
19594 
    oprot.writeFieldStop()
19595 
    oprot.writeStructEnd()
19596 
 
19597 
  def validate(self):
19598 
    return
19599 
 
19600 
 
19601 
  def __repr__(self):
19602 
    L = ['%s=%r' % (key, value)
19603 
      for key, value in self.__dict__.iteritems()]
19604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19605 
 
19606 
  def __eq__(self, other):
19607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19608 
 
19609 
  def __ne__(self, other):
19610 
    return not (self == other)
19611 
 
19612 
class markTransactionAsProcessed_args:
19613 
  """
19614 
  Attributes:
19615 
   - transactionId
19616 
   - category
19617 
  """
19618 
 
19619 
  thrift_spec = (
19620 
    None, # 0
19621 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19622 
    (2, TType.I32, 'category', None, None, ), # 2
19623 
  )
19624 
 
19625 
  def __init__(self, transactionId=None, category=None,):
19626 
    self.transactionId = transactionId
19627 
    self.category = category
19628 
 
19629 
  def read(self, iprot):
19630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19632 
      return
19633 
    iprot.readStructBegin()
19634 
    while True:
19635 
      (fname, ftype, fid) = iprot.readFieldBegin()
19636 
      if ftype == TType.STOP:
19637 
        break
19638 
      if fid == 1:
19639 
        if ftype == TType.I64:
19640 
          self.transactionId = iprot.readI64();
19641 
        else:
19642 
          iprot.skip(ftype)
19643 
      elif fid == 2:
19644 
        if ftype == TType.I32:
19645 
          self.category = iprot.readI32();
19646 
        else:
19647 
          iprot.skip(ftype)
19648 
      else:
19649 
        iprot.skip(ftype)
19650 
      iprot.readFieldEnd()
19651 
    iprot.readStructEnd()
19652 
 
19653 
  def write(self, oprot):
19654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19656 
      return
19657 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19658 
    if self.transactionId is not None:
19659 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19660 
      oprot.writeI64(self.transactionId)
19661 
      oprot.writeFieldEnd()
19662 
    if self.category is not None:
19663 
      oprot.writeFieldBegin('category', TType.I32, 2)
19664 
      oprot.writeI32(self.category)
19665 
      oprot.writeFieldEnd()
19666 
    oprot.writeFieldStop()
19667 
    oprot.writeStructEnd()
19668 
 
19669 
  def validate(self):
19670 
    return
19671 
 
19672 
 
19673 
  def __repr__(self):
19674 
    L = ['%s=%r' % (key, value)
19675 
      for key, value in self.__dict__.iteritems()]
19676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19677 
 
19678 
  def __eq__(self, other):
19679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19680 
 
19681 
  def __ne__(self, other):
19682 
    return not (self == other)
19683 
 
19684 
class markTransactionAsProcessed_result:
19685 
 
19686 
  thrift_spec = (
19687 
  )
19688 
 
19689 
  def read(self, iprot):
19690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19692 
      return
19693 
    iprot.readStructBegin()
19694 
    while True:
19695 
      (fname, ftype, fid) = iprot.readFieldBegin()
19696 
      if ftype == TType.STOP:
19697 
        break
19698 
      else:
19699 
        iprot.skip(ftype)
19700 
      iprot.readFieldEnd()
19701 
    iprot.readStructEnd()
19702 
 
19703 
  def write(self, oprot):
19704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19706 
      return
19707 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19708 
    oprot.writeFieldStop()
19709 
    oprot.writeStructEnd()
19710 
 
19711 
  def validate(self):
19712 
    return
19713 
 
19714 
 
19715 
  def __repr__(self):
19716 
    L = ['%s=%r' % (key, value)
19717 
      for key, value in self.__dict__.iteritems()]
19718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19719 
 
19720 
  def __eq__(self, other):
19721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19722 
 
19723 
  def __ne__(self, other):
19724 
    return not (self == other)
4018 chandransh 19725 
 
19726 
class getItemWiseRiskyOrdersCount_args:
19727 
 
19728 
  thrift_spec = (
19729 
  )
19730 
 
19731 
  def read(self, iprot):
19732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19734 
      return
19735 
    iprot.readStructBegin()
19736 
    while True:
19737 
      (fname, ftype, fid) = iprot.readFieldBegin()
19738 
      if ftype == TType.STOP:
19739 
        break
19740 
      else:
19741 
        iprot.skip(ftype)
19742 
      iprot.readFieldEnd()
19743 
    iprot.readStructEnd()
19744 
 
19745 
  def write(self, oprot):
19746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19748 
      return
19749 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19750 
    oprot.writeFieldStop()
19751 
    oprot.writeStructEnd()
19752 
 
19753 
  def validate(self):
19754 
    return
19755 
 
19756 
 
19757 
  def __repr__(self):
19758 
    L = ['%s=%r' % (key, value)
19759 
      for key, value in self.__dict__.iteritems()]
19760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19761 
 
19762 
  def __eq__(self, other):
19763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19764 
 
19765 
  def __ne__(self, other):
19766 
    return not (self == other)
19767 
 
19768 
class getItemWiseRiskyOrdersCount_result:
19769 
  """
19770 
  Attributes:
19771 
   - success
19772 
  """
19773 
 
19774 
  thrift_spec = (
19775 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19776 
  )
19777 
 
19778 
  def __init__(self, success=None,):
19779 
    self.success = success
19780 
 
19781 
  def read(self, iprot):
19782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19784 
      return
19785 
    iprot.readStructBegin()
19786 
    while True:
19787 
      (fname, ftype, fid) = iprot.readFieldBegin()
19788 
      if ftype == TType.STOP:
19789 
        break
19790 
      if fid == 0:
19791 
        if ftype == TType.MAP:
19792 
          self.success = {}
6031 rajveer 19793 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19794 
          for _i439 in xrange(_size435):
19795 
            _key440 = iprot.readI64();
19796 
            _val441 = iprot.readI64();
19797 
            self.success[_key440] = _val441
4018 chandransh 19798 
          iprot.readMapEnd()
19799 
        else:
19800 
          iprot.skip(ftype)
19801 
      else:
19802 
        iprot.skip(ftype)
19803 
      iprot.readFieldEnd()
19804 
    iprot.readStructEnd()
19805 
 
19806 
  def write(self, oprot):
19807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19809 
      return
19810 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19811 
    if self.success is not None:
19812 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19813 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 19814 
      for kiter442,viter443 in self.success.items():
19815 
        oprot.writeI64(kiter442)
19816 
        oprot.writeI64(viter443)
4018 chandransh 19817 
      oprot.writeMapEnd()
19818 
      oprot.writeFieldEnd()
19819 
    oprot.writeFieldStop()
19820 
    oprot.writeStructEnd()
19821 
 
19822 
  def validate(self):
19823 
    return
19824 
 
19825 
 
19826 
  def __repr__(self):
19827 
    L = ['%s=%r' % (key, value)
19828 
      for key, value in self.__dict__.iteritems()]
19829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19830 
 
19831 
  def __eq__(self, other):
19832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19833 
 
19834 
  def __ne__(self, other):
19835 
    return not (self == other)
4247 rajveer 19836 
 
4295 varun.gupt 19837 
class getOrdersForItemIds_args:
19838 
  """
19839 
  Attributes:
19840 
   - itemIds
19841 
  """
19842 
 
19843 
  thrift_spec = (
19844 
    None, # 0
19845 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19846 
  )
19847 
 
19848 
  def __init__(self, itemIds=None,):
19849 
    self.itemIds = itemIds
19850 
 
19851 
  def read(self, iprot):
19852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19854 
      return
19855 
    iprot.readStructBegin()
19856 
    while True:
19857 
      (fname, ftype, fid) = iprot.readFieldBegin()
19858 
      if ftype == TType.STOP:
19859 
        break
19860 
      if fid == 1:
19861 
        if ftype == TType.LIST:
19862 
          self.itemIds = []
6031 rajveer 19863 
          (_etype447, _size444) = iprot.readListBegin()
19864 
          for _i448 in xrange(_size444):
19865 
            _elem449 = iprot.readI64();
19866 
            self.itemIds.append(_elem449)
4295 varun.gupt 19867 
          iprot.readListEnd()
19868 
        else:
19869 
          iprot.skip(ftype)
19870 
      else:
19871 
        iprot.skip(ftype)
19872 
      iprot.readFieldEnd()
19873 
    iprot.readStructEnd()
19874 
 
19875 
  def write(self, oprot):
19876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19878 
      return
19879 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19880 
    if self.itemIds is not None:
19881 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19882 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6031 rajveer 19883 
      for iter450 in self.itemIds:
19884 
        oprot.writeI64(iter450)
4295 varun.gupt 19885 
      oprot.writeListEnd()
19886 
      oprot.writeFieldEnd()
19887 
    oprot.writeFieldStop()
19888 
    oprot.writeStructEnd()
19889 
 
19890 
  def validate(self):
19891 
    return
19892 
 
19893 
 
19894 
  def __repr__(self):
19895 
    L = ['%s=%r' % (key, value)
19896 
      for key, value in self.__dict__.iteritems()]
19897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19898 
 
19899 
  def __eq__(self, other):
19900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19901 
 
19902 
  def __ne__(self, other):
19903 
    return not (self == other)
19904 
 
19905 
class getOrdersForItemIds_result:
19906 
  """
19907 
  Attributes:
19908 
   - success
19909 
  """
19910 
 
19911 
  thrift_spec = (
19912 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19913 
  )
19914 
 
19915 
  def __init__(self, success=None,):
19916 
    self.success = success
19917 
 
19918 
  def read(self, iprot):
19919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19921 
      return
19922 
    iprot.readStructBegin()
19923 
    while True:
19924 
      (fname, ftype, fid) = iprot.readFieldBegin()
19925 
      if ftype == TType.STOP:
19926 
        break
19927 
      if fid == 0:
19928 
        if ftype == TType.LIST:
19929 
          self.success = []
6031 rajveer 19930 
          (_etype454, _size451) = iprot.readListBegin()
19931 
          for _i455 in xrange(_size451):
19932 
            _elem456 = Order()
19933 
            _elem456.read(iprot)
19934 
            self.success.append(_elem456)
4295 varun.gupt 19935 
          iprot.readListEnd()
19936 
        else:
19937 
          iprot.skip(ftype)
19938 
      else:
19939 
        iprot.skip(ftype)
19940 
      iprot.readFieldEnd()
19941 
    iprot.readStructEnd()
19942 
 
19943 
  def write(self, oprot):
19944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19946 
      return
19947 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19948 
    if self.success is not None:
19949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 19951 
      for iter457 in self.success:
19952 
        iter457.write(oprot)
4295 varun.gupt 19953 
      oprot.writeListEnd()
19954 
      oprot.writeFieldEnd()
19955 
    oprot.writeFieldStop()
19956 
    oprot.writeStructEnd()
19957 
 
19958 
  def validate(self):
19959 
    return
19960 
 
19961 
 
19962 
  def __repr__(self):
19963 
    L = ['%s=%r' % (key, value)
19964 
      for key, value in self.__dict__.iteritems()]
19965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19966 
 
19967 
  def __eq__(self, other):
19968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19969 
 
19970 
  def __ne__(self, other):
19971 
    return not (self == other)
19972 
 
4247 rajveer 19973 
class markOrderCancellationRequestReceived_args:
19974 
  """
19975 
  Attributes:
19976 
   - orderId
19977 
  """
19978 
 
19979 
  thrift_spec = (
19980 
    None, # 0
19981 
    (1, TType.I64, 'orderId', None, None, ), # 1
19982 
  )
19983 
 
19984 
  def __init__(self, orderId=None,):
19985 
    self.orderId = orderId
19986 
 
19987 
  def read(self, iprot):
19988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19990 
      return
19991 
    iprot.readStructBegin()
19992 
    while True:
19993 
      (fname, ftype, fid) = iprot.readFieldBegin()
19994 
      if ftype == TType.STOP:
19995 
        break
19996 
      if fid == 1:
19997 
        if ftype == TType.I64:
19998 
          self.orderId = iprot.readI64();
19999 
        else:
20000 
          iprot.skip(ftype)
20001 
      else:
20002 
        iprot.skip(ftype)
20003 
      iprot.readFieldEnd()
20004 
    iprot.readStructEnd()
20005 
 
20006 
  def write(self, oprot):
20007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20009 
      return
20010 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20011 
    if self.orderId is not None:
20012 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20013 
      oprot.writeI64(self.orderId)
20014 
      oprot.writeFieldEnd()
20015 
    oprot.writeFieldStop()
20016 
    oprot.writeStructEnd()
20017 
 
20018 
  def validate(self):
20019 
    return
20020 
 
20021 
 
20022 
  def __repr__(self):
20023 
    L = ['%s=%r' % (key, value)
20024 
      for key, value in self.__dict__.iteritems()]
20025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20026 
 
20027 
  def __eq__(self, other):
20028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20029 
 
20030 
  def __ne__(self, other):
20031 
    return not (self == other)
20032 
 
20033 
class markOrderCancellationRequestReceived_result:
20034 
  """
20035 
  Attributes:
20036 
   - ex
20037 
  """
20038 
 
20039 
  thrift_spec = (
20040 
    None, # 0
20041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20042 
  )
20043 
 
20044 
  def __init__(self, ex=None,):
20045 
    self.ex = ex
20046 
 
20047 
  def read(self, iprot):
20048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20050 
      return
20051 
    iprot.readStructBegin()
20052 
    while True:
20053 
      (fname, ftype, fid) = iprot.readFieldBegin()
20054 
      if ftype == TType.STOP:
20055 
        break
20056 
      if fid == 1:
20057 
        if ftype == TType.STRUCT:
20058 
          self.ex = TransactionServiceException()
20059 
          self.ex.read(iprot)
20060 
        else:
20061 
          iprot.skip(ftype)
20062 
      else:
20063 
        iprot.skip(ftype)
20064 
      iprot.readFieldEnd()
20065 
    iprot.readStructEnd()
20066 
 
20067 
  def write(self, oprot):
20068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20070 
      return
20071 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20072 
    if self.ex is not None:
20073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20074 
      self.ex.write(oprot)
20075 
      oprot.writeFieldEnd()
20076 
    oprot.writeFieldStop()
20077 
    oprot.writeStructEnd()
20078 
 
20079 
  def validate(self):
20080 
    return
20081 
 
20082 
 
20083 
  def __repr__(self):
20084 
    L = ['%s=%r' % (key, value)
20085 
      for key, value in self.__dict__.iteritems()]
20086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20087 
 
20088 
  def __eq__(self, other):
20089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20090 
 
20091 
  def __ne__(self, other):
20092 
    return not (self == other)
20093 
 
20094 
class markOrderCancellationRequestConfirmed_args:
20095 
  """
20096 
  Attributes:
20097 
   - orderId
20098 
  """
20099 
 
20100 
  thrift_spec = (
20101 
    None, # 0
20102 
    (1, TType.I64, 'orderId', None, None, ), # 1
20103 
  )
20104 
 
20105 
  def __init__(self, orderId=None,):
20106 
    self.orderId = orderId
20107 
 
20108 
  def read(self, iprot):
20109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20111 
      return
20112 
    iprot.readStructBegin()
20113 
    while True:
20114 
      (fname, ftype, fid) = iprot.readFieldBegin()
20115 
      if ftype == TType.STOP:
20116 
        break
20117 
      if fid == 1:
20118 
        if ftype == TType.I64:
20119 
          self.orderId = iprot.readI64();
20120 
        else:
20121 
          iprot.skip(ftype)
20122 
      else:
20123 
        iprot.skip(ftype)
20124 
      iprot.readFieldEnd()
20125 
    iprot.readStructEnd()
20126 
 
20127 
  def write(self, oprot):
20128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20130 
      return
20131 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20132 
    if self.orderId is not None:
20133 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20134 
      oprot.writeI64(self.orderId)
20135 
      oprot.writeFieldEnd()
20136 
    oprot.writeFieldStop()
20137 
    oprot.writeStructEnd()
20138 
 
20139 
  def validate(self):
20140 
    return
20141 
 
20142 
 
20143 
  def __repr__(self):
20144 
    L = ['%s=%r' % (key, value)
20145 
      for key, value in self.__dict__.iteritems()]
20146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20147 
 
20148 
  def __eq__(self, other):
20149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20150 
 
20151 
  def __ne__(self, other):
20152 
    return not (self == other)
20153 
 
20154 
class markOrderCancellationRequestConfirmed_result:
20155 
  """
20156 
  Attributes:
20157 
   - ex
20158 
  """
20159 
 
20160 
  thrift_spec = (
20161 
    None, # 0
20162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20163 
  )
20164 
 
20165 
  def __init__(self, ex=None,):
20166 
    self.ex = ex
20167 
 
20168 
  def read(self, iprot):
20169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20171 
      return
20172 
    iprot.readStructBegin()
20173 
    while True:
20174 
      (fname, ftype, fid) = iprot.readFieldBegin()
20175 
      if ftype == TType.STOP:
20176 
        break
20177 
      if fid == 1:
20178 
        if ftype == TType.STRUCT:
20179 
          self.ex = TransactionServiceException()
20180 
          self.ex.read(iprot)
20181 
        else:
20182 
          iprot.skip(ftype)
20183 
      else:
20184 
        iprot.skip(ftype)
20185 
      iprot.readFieldEnd()
20186 
    iprot.readStructEnd()
20187 
 
20188 
  def write(self, oprot):
20189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20191 
      return
20192 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20193 
    if self.ex is not None:
20194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20195 
      self.ex.write(oprot)
20196 
      oprot.writeFieldEnd()
20197 
    oprot.writeFieldStop()
20198 
    oprot.writeStructEnd()
20199 
 
20200 
  def validate(self):
20201 
    return
20202 
 
20203 
 
20204 
  def __repr__(self):
20205 
    L = ['%s=%r' % (key, value)
20206 
      for key, value in self.__dict__.iteritems()]
20207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20208 
 
20209 
  def __eq__(self, other):
20210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20211 
 
20212 
  def __ne__(self, other):
20213 
    return not (self == other)
20214 
 
20215 
class markOrderCancellationRequestDenied_args:
20216 
  """
20217 
  Attributes:
20218 
   - orderId
20219 
  """
20220 
 
20221 
  thrift_spec = (
20222 
    None, # 0
20223 
    (1, TType.I64, 'orderId', None, None, ), # 1
20224 
  )
20225 
 
20226 
  def __init__(self, orderId=None,):
20227 
    self.orderId = orderId
20228 
 
20229 
  def read(self, iprot):
20230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20232 
      return
20233 
    iprot.readStructBegin()
20234 
    while True:
20235 
      (fname, ftype, fid) = iprot.readFieldBegin()
20236 
      if ftype == TType.STOP:
20237 
        break
20238 
      if fid == 1:
20239 
        if ftype == TType.I64:
20240 
          self.orderId = iprot.readI64();
20241 
        else:
20242 
          iprot.skip(ftype)
20243 
      else:
20244 
        iprot.skip(ftype)
20245 
      iprot.readFieldEnd()
20246 
    iprot.readStructEnd()
20247 
 
20248 
  def write(self, oprot):
20249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20251 
      return
20252 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20253 
    if self.orderId is not None:
20254 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20255 
      oprot.writeI64(self.orderId)
20256 
      oprot.writeFieldEnd()
20257 
    oprot.writeFieldStop()
20258 
    oprot.writeStructEnd()
20259 
 
20260 
  def validate(self):
20261 
    return
20262 
 
20263 
 
20264 
  def __repr__(self):
20265 
    L = ['%s=%r' % (key, value)
20266 
      for key, value in self.__dict__.iteritems()]
20267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20268 
 
20269 
  def __eq__(self, other):
20270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20271 
 
20272 
  def __ne__(self, other):
20273 
    return not (self == other)
20274 
 
20275 
class markOrderCancellationRequestDenied_result:
20276 
  """
20277 
  Attributes:
20278 
   - ex
20279 
  """
20280 
 
20281 
  thrift_spec = (
20282 
    None, # 0
20283 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20284 
  )
20285 
 
20286 
  def __init__(self, ex=None,):
20287 
    self.ex = ex
20288 
 
20289 
  def read(self, iprot):
20290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20292 
      return
20293 
    iprot.readStructBegin()
20294 
    while True:
20295 
      (fname, ftype, fid) = iprot.readFieldBegin()
20296 
      if ftype == TType.STOP:
20297 
        break
20298 
      if fid == 1:
20299 
        if ftype == TType.STRUCT:
20300 
          self.ex = TransactionServiceException()
20301 
          self.ex.read(iprot)
20302 
        else:
20303 
          iprot.skip(ftype)
20304 
      else:
20305 
        iprot.skip(ftype)
20306 
      iprot.readFieldEnd()
20307 
    iprot.readStructEnd()
20308 
 
20309 
  def write(self, oprot):
20310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20312 
      return
20313 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20314 
    if self.ex is not None:
20315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20316 
      self.ex.write(oprot)
20317 
      oprot.writeFieldEnd()
20318 
    oprot.writeFieldStop()
20319 
    oprot.writeStructEnd()
20320 
 
20321 
  def validate(self):
20322 
    return
20323 
 
20324 
 
20325 
  def __repr__(self):
20326 
    L = ['%s=%r' % (key, value)
20327 
      for key, value in self.__dict__.iteritems()]
20328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20329 
 
20330 
  def __eq__(self, other):
20331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20332 
 
20333 
  def __ne__(self, other):
20334 
    return not (self == other)
20335 
 
4258 rajveer 20336 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20337 
  """
20338 
  Attributes:
4258 rajveer 20339 
   - transactionId
4247 rajveer 20340 
  """
20341 
 
20342 
  thrift_spec = (
20343 
    None, # 0
4258 rajveer 20344 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20345 
  )
20346 
 
4258 rajveer 20347 
  def __init__(self, transactionId=None,):
20348 
    self.transactionId = transactionId
4247 rajveer 20349 
 
20350 
  def read(self, iprot):
20351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20353 
      return
20354 
    iprot.readStructBegin()
20355 
    while True:
20356 
      (fname, ftype, fid) = iprot.readFieldBegin()
20357 
      if ftype == TType.STOP:
20358 
        break
20359 
      if fid == 1:
20360 
        if ftype == TType.I64:
4258 rajveer 20361 
          self.transactionId = iprot.readI64();
4247 rajveer 20362 
        else:
20363 
          iprot.skip(ftype)
20364 
      else:
20365 
        iprot.skip(ftype)
20366 
      iprot.readFieldEnd()
20367 
    iprot.readStructEnd()
20368 
 
20369 
  def write(self, oprot):
20370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20372 
      return
4258 rajveer 20373 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20374 
    if self.transactionId is not None:
20375 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20376 
      oprot.writeI64(self.transactionId)
4247 rajveer 20377 
      oprot.writeFieldEnd()
20378 
    oprot.writeFieldStop()
20379 
    oprot.writeStructEnd()
20380 
 
20381 
  def validate(self):
20382 
    return
20383 
 
20384 
 
20385 
  def __repr__(self):
20386 
    L = ['%s=%r' % (key, value)
20387 
      for key, value in self.__dict__.iteritems()]
20388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20389 
 
20390 
  def __eq__(self, other):
20391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20392 
 
20393 
  def __ne__(self, other):
20394 
    return not (self == other)
20395 
 
4258 rajveer 20396 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20397 
  """
20398 
  Attributes:
20399 
   - ex
20400 
  """
20401 
 
20402 
  thrift_spec = (
20403 
    None, # 0
20404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20405 
  )
20406 
 
20407 
  def __init__(self, ex=None,):
20408 
    self.ex = ex
20409 
 
20410 
  def read(self, iprot):
20411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20413 
      return
20414 
    iprot.readStructBegin()
20415 
    while True:
20416 
      (fname, ftype, fid) = iprot.readFieldBegin()
20417 
      if ftype == TType.STOP:
20418 
        break
20419 
      if fid == 1:
20420 
        if ftype == TType.STRUCT:
20421 
          self.ex = TransactionServiceException()
20422 
          self.ex.read(iprot)
20423 
        else:
20424 
          iprot.skip(ftype)
20425 
      else:
20426 
        iprot.skip(ftype)
20427 
      iprot.readFieldEnd()
20428 
    iprot.readStructEnd()
20429 
 
20430 
  def write(self, oprot):
20431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20433 
      return
4258 rajveer 20434 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20435 
    if self.ex is not None:
20436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20437 
      self.ex.write(oprot)
20438 
      oprot.writeFieldEnd()
20439 
    oprot.writeFieldStop()
20440 
    oprot.writeStructEnd()
20441 
 
20442 
  def validate(self):
20443 
    return
20444 
 
20445 
 
20446 
  def __repr__(self):
20447 
    L = ['%s=%r' % (key, value)
20448 
      for key, value in self.__dict__.iteritems()]
20449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20450 
 
20451 
  def __eq__(self, other):
20452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20453 
 
20454 
  def __ne__(self, other):
20455 
    return not (self == other)
4259 anupam.sin 20456 
 
20457 
class refundTransaction_args:
20458 
  """
20459 
  Attributes:
20460 
   - transactionId
20461 
   - refundedBy
20462 
   - reason
20463 
  """
20464 
 
20465 
  thrift_spec = (
20466 
    None, # 0
20467 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20468 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20469 
    (3, TType.STRING, 'reason', None, None, ), # 3
20470 
  )
20471 
 
20472 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20473 
    self.transactionId = transactionId
20474 
    self.refundedBy = refundedBy
20475 
    self.reason = reason
20476 
 
20477 
  def read(self, iprot):
20478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20480 
      return
20481 
    iprot.readStructBegin()
20482 
    while True:
20483 
      (fname, ftype, fid) = iprot.readFieldBegin()
20484 
      if ftype == TType.STOP:
20485 
        break
20486 
      if fid == 1:
20487 
        if ftype == TType.I64:
20488 
          self.transactionId = iprot.readI64();
20489 
        else:
20490 
          iprot.skip(ftype)
20491 
      elif fid == 2:
20492 
        if ftype == TType.STRING:
20493 
          self.refundedBy = iprot.readString();
20494 
        else:
20495 
          iprot.skip(ftype)
20496 
      elif fid == 3:
20497 
        if ftype == TType.STRING:
20498 
          self.reason = iprot.readString();
20499 
        else:
20500 
          iprot.skip(ftype)
20501 
      else:
20502 
        iprot.skip(ftype)
20503 
      iprot.readFieldEnd()
20504 
    iprot.readStructEnd()
20505 
 
20506 
  def write(self, oprot):
20507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20509 
      return
20510 
    oprot.writeStructBegin('refundTransaction_args')
20511 
    if self.transactionId is not None:
20512 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20513 
      oprot.writeI64(self.transactionId)
20514 
      oprot.writeFieldEnd()
20515 
    if self.refundedBy is not None:
20516 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20517 
      oprot.writeString(self.refundedBy)
20518 
      oprot.writeFieldEnd()
20519 
    if self.reason is not None:
20520 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20521 
      oprot.writeString(self.reason)
20522 
      oprot.writeFieldEnd()
20523 
    oprot.writeFieldStop()
20524 
    oprot.writeStructEnd()
20525 
 
20526 
  def validate(self):
20527 
    return
20528 
 
20529 
 
20530 
  def __repr__(self):
20531 
    L = ['%s=%r' % (key, value)
20532 
      for key, value in self.__dict__.iteritems()]
20533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20534 
 
20535 
  def __eq__(self, other):
20536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20537 
 
20538 
  def __ne__(self, other):
20539 
    return not (self == other)
20540 
 
20541 
class refundTransaction_result:
20542 
  """
20543 
  Attributes:
20544 
   - ex
20545 
  """
20546 
 
20547 
  thrift_spec = (
20548 
    None, # 0
20549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20550 
  )
20551 
 
20552 
  def __init__(self, ex=None,):
20553 
    self.ex = ex
20554 
 
20555 
  def read(self, iprot):
20556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20558 
      return
20559 
    iprot.readStructBegin()
20560 
    while True:
20561 
      (fname, ftype, fid) = iprot.readFieldBegin()
20562 
      if ftype == TType.STOP:
20563 
        break
20564 
      if fid == 1:
20565 
        if ftype == TType.STRUCT:
20566 
          self.ex = TransactionServiceException()
20567 
          self.ex.read(iprot)
20568 
        else:
20569 
          iprot.skip(ftype)
20570 
      else:
20571 
        iprot.skip(ftype)
20572 
      iprot.readFieldEnd()
20573 
    iprot.readStructEnd()
20574 
 
20575 
  def write(self, oprot):
20576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20578 
      return
20579 
    oprot.writeStructBegin('refundTransaction_result')
20580 
    if self.ex is not None:
20581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20582 
      self.ex.write(oprot)
20583 
      oprot.writeFieldEnd()
20584 
    oprot.writeFieldStop()
20585 
    oprot.writeStructEnd()
20586 
 
20587 
  def validate(self):
20588 
    return
20589 
 
20590 
 
20591 
  def __repr__(self):
20592 
    L = ['%s=%r' % (key, value)
20593 
      for key, value in self.__dict__.iteritems()]
20594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20595 
 
20596 
  def __eq__(self, other):
20597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20598 
 
20599 
  def __ne__(self, other):
20600 
    return not (self == other)
4285 rajveer 20601 
 
4324 mandeep.dh 20602 
class updateShipmentAddress_args:
20603 
  """
20604 
  Attributes:
20605 
   - orderId
20606 
   - addressId
20607 
  """
20608 
 
20609 
  thrift_spec = (
20610 
    None, # 0
20611 
    (1, TType.I64, 'orderId', None, None, ), # 1
20612 
    (2, TType.I64, 'addressId', None, None, ), # 2
20613 
  )
20614 
 
20615 
  def __init__(self, orderId=None, addressId=None,):
20616 
    self.orderId = orderId
20617 
    self.addressId = addressId
20618 
 
20619 
  def read(self, iprot):
20620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20622 
      return
20623 
    iprot.readStructBegin()
20624 
    while True:
20625 
      (fname, ftype, fid) = iprot.readFieldBegin()
20626 
      if ftype == TType.STOP:
20627 
        break
20628 
      if fid == 1:
20629 
        if ftype == TType.I64:
20630 
          self.orderId = iprot.readI64();
20631 
        else:
20632 
          iprot.skip(ftype)
20633 
      elif fid == 2:
20634 
        if ftype == TType.I64:
20635 
          self.addressId = iprot.readI64();
20636 
        else:
20637 
          iprot.skip(ftype)
20638 
      else:
20639 
        iprot.skip(ftype)
20640 
      iprot.readFieldEnd()
20641 
    iprot.readStructEnd()
20642 
 
20643 
  def write(self, oprot):
20644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20646 
      return
20647 
    oprot.writeStructBegin('updateShipmentAddress_args')
20648 
    if self.orderId is not None:
20649 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20650 
      oprot.writeI64(self.orderId)
20651 
      oprot.writeFieldEnd()
20652 
    if self.addressId is not None:
20653 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20654 
      oprot.writeI64(self.addressId)
20655 
      oprot.writeFieldEnd()
20656 
    oprot.writeFieldStop()
20657 
    oprot.writeStructEnd()
20658 
 
20659 
  def validate(self):
20660 
    return
20661 
 
20662 
 
20663 
  def __repr__(self):
20664 
    L = ['%s=%r' % (key, value)
20665 
      for key, value in self.__dict__.iteritems()]
20666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20667 
 
20668 
  def __eq__(self, other):
20669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20670 
 
20671 
  def __ne__(self, other):
20672 
    return not (self == other)
20673 
 
20674 
class updateShipmentAddress_result:
20675 
  """
20676 
  Attributes:
20677 
   - ex
20678 
  """
20679 
 
20680 
  thrift_spec = (
20681 
    None, # 0
20682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20683 
  )
20684 
 
20685 
  def __init__(self, ex=None,):
20686 
    self.ex = ex
20687 
 
20688 
  def read(self, iprot):
20689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20691 
      return
20692 
    iprot.readStructBegin()
20693 
    while True:
20694 
      (fname, ftype, fid) = iprot.readFieldBegin()
20695 
      if ftype == TType.STOP:
20696 
        break
20697 
      if fid == 1:
20698 
        if ftype == TType.STRUCT:
20699 
          self.ex = TransactionServiceException()
20700 
          self.ex.read(iprot)
20701 
        else:
20702 
          iprot.skip(ftype)
20703 
      else:
20704 
        iprot.skip(ftype)
20705 
      iprot.readFieldEnd()
20706 
    iprot.readStructEnd()
20707 
 
20708 
  def write(self, oprot):
20709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20711 
      return
20712 
    oprot.writeStructBegin('updateShipmentAddress_result')
20713 
    if self.ex is not None:
20714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20715 
      self.ex.write(oprot)
20716 
      oprot.writeFieldEnd()
20717 
    oprot.writeFieldStop()
20718 
    oprot.writeStructEnd()
20719 
 
20720 
  def validate(self):
20721 
    return
20722 
 
20723 
 
20724 
  def __repr__(self):
20725 
    L = ['%s=%r' % (key, value)
20726 
      for key, value in self.__dict__.iteritems()]
20727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20728 
 
20729 
  def __eq__(self, other):
20730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20731 
 
20732 
  def __ne__(self, other):
20733 
    return not (self == other)
20734 
 
4285 rajveer 20735 
class acceptOrdersForItemId_args:
20736 
  """
20737 
  Attributes:
20738 
   - itemId
20739 
   - inventory
20740 
  """
20741 
 
20742 
  thrift_spec = (
20743 
    None, # 0
20744 
    (1, TType.I64, 'itemId', None, None, ), # 1
20745 
    (2, TType.I64, 'inventory', None, None, ), # 2
20746 
  )
20747 
 
20748 
  def __init__(self, itemId=None, inventory=None,):
20749 
    self.itemId = itemId
20750 
    self.inventory = inventory
20751 
 
20752 
  def read(self, iprot):
20753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20755 
      return
20756 
    iprot.readStructBegin()
20757 
    while True:
20758 
      (fname, ftype, fid) = iprot.readFieldBegin()
20759 
      if ftype == TType.STOP:
20760 
        break
20761 
      if fid == 1:
20762 
        if ftype == TType.I64:
20763 
          self.itemId = iprot.readI64();
20764 
        else:
20765 
          iprot.skip(ftype)
20766 
      elif fid == 2:
20767 
        if ftype == TType.I64:
20768 
          self.inventory = iprot.readI64();
20769 
        else:
20770 
          iprot.skip(ftype)
20771 
      else:
20772 
        iprot.skip(ftype)
20773 
      iprot.readFieldEnd()
20774 
    iprot.readStructEnd()
20775 
 
20776 
  def write(self, oprot):
20777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20779 
      return
20780 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20781 
    if self.itemId is not None:
20782 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20783 
      oprot.writeI64(self.itemId)
20784 
      oprot.writeFieldEnd()
20785 
    if self.inventory is not None:
20786 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20787 
      oprot.writeI64(self.inventory)
20788 
      oprot.writeFieldEnd()
20789 
    oprot.writeFieldStop()
20790 
    oprot.writeStructEnd()
20791 
 
20792 
  def validate(self):
20793 
    return
20794 
 
20795 
 
20796 
  def __repr__(self):
20797 
    L = ['%s=%r' % (key, value)
20798 
      for key, value in self.__dict__.iteritems()]
20799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20800 
 
20801 
  def __eq__(self, other):
20802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20803 
 
20804 
  def __ne__(self, other):
20805 
    return not (self == other)
20806 
 
20807 
class acceptOrdersForItemId_result:
20808 
  """
20809 
  Attributes:
20810 
   - success
20811 
   - ex
20812 
  """
20813 
 
20814 
  thrift_spec = (
20815 
    (0, TType.BOOL, 'success', None, None, ), # 0
20816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20817 
  )
20818 
 
20819 
  def __init__(self, success=None, ex=None,):
20820 
    self.success = success
20821 
    self.ex = ex
20822 
 
20823 
  def read(self, iprot):
20824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20826 
      return
20827 
    iprot.readStructBegin()
20828 
    while True:
20829 
      (fname, ftype, fid) = iprot.readFieldBegin()
20830 
      if ftype == TType.STOP:
20831 
        break
20832 
      if fid == 0:
20833 
        if ftype == TType.BOOL:
20834 
          self.success = iprot.readBool();
20835 
        else:
20836 
          iprot.skip(ftype)
20837 
      elif fid == 1:
20838 
        if ftype == TType.STRUCT:
20839 
          self.ex = TransactionServiceException()
20840 
          self.ex.read(iprot)
20841 
        else:
20842 
          iprot.skip(ftype)
20843 
      else:
20844 
        iprot.skip(ftype)
20845 
      iprot.readFieldEnd()
20846 
    iprot.readStructEnd()
20847 
 
20848 
  def write(self, oprot):
20849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20851 
      return
20852 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20853 
    if self.success is not None:
20854 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20855 
      oprot.writeBool(self.success)
20856 
      oprot.writeFieldEnd()
20857 
    if self.ex is not None:
20858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20859 
      self.ex.write(oprot)
20860 
      oprot.writeFieldEnd()
20861 
    oprot.writeFieldStop()
20862 
    oprot.writeStructEnd()
20863 
 
20864 
  def validate(self):
20865 
    return
20866 
 
20867 
 
20868 
  def __repr__(self):
20869 
    L = ['%s=%r' % (key, value)
20870 
      for key, value in self.__dict__.iteritems()]
20871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20872 
 
20873 
  def __eq__(self, other):
20874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20875 
 
20876 
  def __ne__(self, other):
20877 
    return not (self == other)
4303 rajveer 20878 
 
20879 
class markOrdersAsPORaised_args:
20880 
  """
20881 
  Attributes:
20882 
   - vendorId
20883 
   - itemId
20884 
   - quantity
20885 
   - estimate
4369 rajveer 20886 
   - isReminder
4303 rajveer 20887 
  """
20888 
 
20889 
  thrift_spec = (
20890 
    None, # 0
20891 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20892 
    (2, TType.I64, 'itemId', None, None, ), # 2
20893 
    (3, TType.I64, 'quantity', None, None, ), # 3
20894 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20895 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20896 
  )
20897 
 
4369 rajveer 20898 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20899 
    self.vendorId = vendorId
20900 
    self.itemId = itemId
20901 
    self.quantity = quantity
20902 
    self.estimate = estimate
4369 rajveer 20903 
    self.isReminder = isReminder
4303 rajveer 20904 
 
20905 
  def read(self, iprot):
20906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20908 
      return
20909 
    iprot.readStructBegin()
20910 
    while True:
20911 
      (fname, ftype, fid) = iprot.readFieldBegin()
20912 
      if ftype == TType.STOP:
20913 
        break
20914 
      if fid == 1:
20915 
        if ftype == TType.I64:
20916 
          self.vendorId = iprot.readI64();
20917 
        else:
20918 
          iprot.skip(ftype)
20919 
      elif fid == 2:
20920 
        if ftype == TType.I64:
20921 
          self.itemId = iprot.readI64();
20922 
        else:
20923 
          iprot.skip(ftype)
20924 
      elif fid == 3:
20925 
        if ftype == TType.I64:
20926 
          self.quantity = iprot.readI64();
20927 
        else:
20928 
          iprot.skip(ftype)
20929 
      elif fid == 4:
20930 
        if ftype == TType.I64:
20931 
          self.estimate = iprot.readI64();
20932 
        else:
20933 
          iprot.skip(ftype)
4369 rajveer 20934 
      elif fid == 5:
20935 
        if ftype == TType.BOOL:
20936 
          self.isReminder = iprot.readBool();
20937 
        else:
20938 
          iprot.skip(ftype)
4303 rajveer 20939 
      else:
20940 
        iprot.skip(ftype)
20941 
      iprot.readFieldEnd()
20942 
    iprot.readStructEnd()
20943 
 
20944 
  def write(self, oprot):
20945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20947 
      return
20948 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20949 
    if self.vendorId is not None:
20950 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20951 
      oprot.writeI64(self.vendorId)
20952 
      oprot.writeFieldEnd()
20953 
    if self.itemId is not None:
20954 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20955 
      oprot.writeI64(self.itemId)
20956 
      oprot.writeFieldEnd()
20957 
    if self.quantity is not None:
20958 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20959 
      oprot.writeI64(self.quantity)
20960 
      oprot.writeFieldEnd()
20961 
    if self.estimate is not None:
20962 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20963 
      oprot.writeI64(self.estimate)
20964 
      oprot.writeFieldEnd()
4369 rajveer 20965 
    if self.isReminder is not None:
20966 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20967 
      oprot.writeBool(self.isReminder)
20968 
      oprot.writeFieldEnd()
4303 rajveer 20969 
    oprot.writeFieldStop()
20970 
    oprot.writeStructEnd()
20971 
 
20972 
  def validate(self):
20973 
    return
20974 
 
20975 
 
20976 
  def __repr__(self):
20977 
    L = ['%s=%r' % (key, value)
20978 
      for key, value in self.__dict__.iteritems()]
20979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20980 
 
20981 
  def __eq__(self, other):
20982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20983 
 
20984 
  def __ne__(self, other):
20985 
    return not (self == other)
20986 
 
20987 
class markOrdersAsPORaised_result:
20988 
  """
20989 
  Attributes:
20990 
   - ex
20991 
  """
20992 
 
20993 
  thrift_spec = (
20994 
    None, # 0
20995 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20996 
  )
20997 
 
20998 
  def __init__(self, ex=None,):
20999 
    self.ex = ex
21000 
 
21001 
  def read(self, iprot):
21002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21004 
      return
21005 
    iprot.readStructBegin()
21006 
    while True:
21007 
      (fname, ftype, fid) = iprot.readFieldBegin()
21008 
      if ftype == TType.STOP:
21009 
        break
21010 
      if fid == 1:
21011 
        if ftype == TType.STRUCT:
21012 
          self.ex = TransactionServiceException()
21013 
          self.ex.read(iprot)
21014 
        else:
21015 
          iprot.skip(ftype)
21016 
      else:
21017 
        iprot.skip(ftype)
21018 
      iprot.readFieldEnd()
21019 
    iprot.readStructEnd()
21020 
 
21021 
  def write(self, oprot):
21022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21024 
      return
21025 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21026 
    if self.ex is not None:
21027 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21028 
      self.ex.write(oprot)
21029 
      oprot.writeFieldEnd()
21030 
    oprot.writeFieldStop()
21031 
    oprot.writeStructEnd()
21032 
 
21033 
  def validate(self):
21034 
    return
21035 
 
21036 
 
21037 
  def __repr__(self):
21038 
    L = ['%s=%r' % (key, value)
21039 
      for key, value in self.__dict__.iteritems()]
21040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21041 
 
21042 
  def __eq__(self, other):
21043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21044 
 
21045 
  def __ne__(self, other):
21046 
    return not (self == other)
21047 
 
21048 
class markOrdersAsReversalInitiated_args:
21049 
  """
21050 
  Attributes:
21051 
   - vendorId
21052 
   - itemId
21053 
   - quantity
21054 
   - estimate
4369 rajveer 21055 
   - isReminder
4303 rajveer 21056 
  """
21057 
 
21058 
  thrift_spec = (
21059 
    None, # 0
21060 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21061 
    (2, TType.I64, 'itemId', None, None, ), # 2
21062 
    (3, TType.I64, 'quantity', None, None, ), # 3
21063 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21064 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21065 
  )
21066 
 
4369 rajveer 21067 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21068 
    self.vendorId = vendorId
21069 
    self.itemId = itemId
21070 
    self.quantity = quantity
21071 
    self.estimate = estimate
4369 rajveer 21072 
    self.isReminder = isReminder
4303 rajveer 21073 
 
21074 
  def read(self, iprot):
21075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21077 
      return
21078 
    iprot.readStructBegin()
21079 
    while True:
21080 
      (fname, ftype, fid) = iprot.readFieldBegin()
21081 
      if ftype == TType.STOP:
21082 
        break
21083 
      if fid == 1:
21084 
        if ftype == TType.I64:
21085 
          self.vendorId = iprot.readI64();
21086 
        else:
21087 
          iprot.skip(ftype)
21088 
      elif fid == 2:
21089 
        if ftype == TType.I64:
21090 
          self.itemId = iprot.readI64();
21091 
        else:
21092 
          iprot.skip(ftype)
21093 
      elif fid == 3:
21094 
        if ftype == TType.I64:
21095 
          self.quantity = iprot.readI64();
21096 
        else:
21097 
          iprot.skip(ftype)
21098 
      elif fid == 4:
21099 
        if ftype == TType.I64:
21100 
          self.estimate = iprot.readI64();
21101 
        else:
21102 
          iprot.skip(ftype)
4369 rajveer 21103 
      elif fid == 5:
21104 
        if ftype == TType.BOOL:
21105 
          self.isReminder = iprot.readBool();
21106 
        else:
21107 
          iprot.skip(ftype)
4303 rajveer 21108 
      else:
21109 
        iprot.skip(ftype)
21110 
      iprot.readFieldEnd()
21111 
    iprot.readStructEnd()
21112 
 
21113 
  def write(self, oprot):
21114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21116 
      return
21117 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21118 
    if self.vendorId is not None:
21119 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21120 
      oprot.writeI64(self.vendorId)
21121 
      oprot.writeFieldEnd()
21122 
    if self.itemId is not None:
21123 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21124 
      oprot.writeI64(self.itemId)
21125 
      oprot.writeFieldEnd()
21126 
    if self.quantity is not None:
21127 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21128 
      oprot.writeI64(self.quantity)
21129 
      oprot.writeFieldEnd()
21130 
    if self.estimate is not None:
21131 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21132 
      oprot.writeI64(self.estimate)
21133 
      oprot.writeFieldEnd()
4369 rajveer 21134 
    if self.isReminder is not None:
21135 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21136 
      oprot.writeBool(self.isReminder)
21137 
      oprot.writeFieldEnd()
4303 rajveer 21138 
    oprot.writeFieldStop()
21139 
    oprot.writeStructEnd()
21140 
 
21141 
  def validate(self):
21142 
    return
21143 
 
21144 
 
21145 
  def __repr__(self):
21146 
    L = ['%s=%r' % (key, value)
21147 
      for key, value in self.__dict__.iteritems()]
21148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21149 
 
21150 
  def __eq__(self, other):
21151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21152 
 
21153 
  def __ne__(self, other):
21154 
    return not (self == other)
21155 
 
21156 
class markOrdersAsReversalInitiated_result:
21157 
  """
21158 
  Attributes:
21159 
   - ex
21160 
  """
21161 
 
21162 
  thrift_spec = (
21163 
    None, # 0
21164 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21165 
  )
21166 
 
21167 
  def __init__(self, ex=None,):
21168 
    self.ex = ex
21169 
 
21170 
  def read(self, iprot):
21171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21173 
      return
21174 
    iprot.readStructBegin()
21175 
    while True:
21176 
      (fname, ftype, fid) = iprot.readFieldBegin()
21177 
      if ftype == TType.STOP:
21178 
        break
21179 
      if fid == 1:
21180 
        if ftype == TType.STRUCT:
21181 
          self.ex = TransactionServiceException()
21182 
          self.ex.read(iprot)
21183 
        else:
21184 
          iprot.skip(ftype)
21185 
      else:
21186 
        iprot.skip(ftype)
21187 
      iprot.readFieldEnd()
21188 
    iprot.readStructEnd()
21189 
 
21190 
  def write(self, oprot):
21191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21193 
      return
21194 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21195 
    if self.ex is not None:
21196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21197 
      self.ex.write(oprot)
21198 
      oprot.writeFieldEnd()
21199 
    oprot.writeFieldStop()
21200 
    oprot.writeStructEnd()
21201 
 
21202 
  def validate(self):
21203 
    return
21204 
 
21205 
 
21206 
  def __repr__(self):
21207 
    L = ['%s=%r' % (key, value)
21208 
      for key, value in self.__dict__.iteritems()]
21209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21210 
 
21211 
  def __eq__(self, other):
21212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21213 
 
21214 
  def __ne__(self, other):
21215 
    return not (self == other)
21216 
 
21217 
class markOrdersAsNotAvailabke_args:
21218 
  """
21219 
  Attributes:
21220 
   - vendorId
21221 
   - itemId
21222 
   - quantity
21223 
   - estimate
4369 rajveer 21224 
   - isReminder
4303 rajveer 21225 
  """
21226 
 
21227 
  thrift_spec = (
21228 
    None, # 0
21229 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21230 
    (2, TType.I64, 'itemId', None, None, ), # 2
21231 
    (3, TType.I64, 'quantity', None, None, ), # 3
21232 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21233 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21234 
  )
21235 
 
4369 rajveer 21236 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21237 
    self.vendorId = vendorId
21238 
    self.itemId = itemId
21239 
    self.quantity = quantity
21240 
    self.estimate = estimate
4369 rajveer 21241 
    self.isReminder = isReminder
4303 rajveer 21242 
 
21243 
  def read(self, iprot):
21244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21246 
      return
21247 
    iprot.readStructBegin()
21248 
    while True:
21249 
      (fname, ftype, fid) = iprot.readFieldBegin()
21250 
      if ftype == TType.STOP:
21251 
        break
21252 
      if fid == 1:
21253 
        if ftype == TType.I64:
21254 
          self.vendorId = iprot.readI64();
21255 
        else:
21256 
          iprot.skip(ftype)
21257 
      elif fid == 2:
21258 
        if ftype == TType.I64:
21259 
          self.itemId = iprot.readI64();
21260 
        else:
21261 
          iprot.skip(ftype)
21262 
      elif fid == 3:
21263 
        if ftype == TType.I64:
21264 
          self.quantity = iprot.readI64();
21265 
        else:
21266 
          iprot.skip(ftype)
21267 
      elif fid == 4:
21268 
        if ftype == TType.I64:
21269 
          self.estimate = iprot.readI64();
21270 
        else:
21271 
          iprot.skip(ftype)
4369 rajveer 21272 
      elif fid == 5:
21273 
        if ftype == TType.BOOL:
21274 
          self.isReminder = iprot.readBool();
21275 
        else:
21276 
          iprot.skip(ftype)
4303 rajveer 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('markOrdersAsNotAvailabke_args')
21287 
    if self.vendorId is not None:
21288 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21289 
      oprot.writeI64(self.vendorId)
21290 
      oprot.writeFieldEnd()
21291 
    if self.itemId is not None:
21292 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21293 
      oprot.writeI64(self.itemId)
21294 
      oprot.writeFieldEnd()
21295 
    if self.quantity is not None:
21296 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21297 
      oprot.writeI64(self.quantity)
21298 
      oprot.writeFieldEnd()
21299 
    if self.estimate is not None:
21300 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21301 
      oprot.writeI64(self.estimate)
21302 
      oprot.writeFieldEnd()
4369 rajveer 21303 
    if self.isReminder is not None:
21304 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21305 
      oprot.writeBool(self.isReminder)
21306 
      oprot.writeFieldEnd()
4303 rajveer 21307 
    oprot.writeFieldStop()
21308 
    oprot.writeStructEnd()
21309 
 
21310 
  def validate(self):
21311 
    return
21312 
 
21313 
 
21314 
  def __repr__(self):
21315 
    L = ['%s=%r' % (key, value)
21316 
      for key, value in self.__dict__.iteritems()]
21317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21318 
 
21319 
  def __eq__(self, other):
21320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21321 
 
21322 
  def __ne__(self, other):
21323 
    return not (self == other)
21324 
 
21325 
class markOrdersAsNotAvailabke_result:
21326 
  """
21327 
  Attributes:
21328 
   - ex
21329 
  """
21330 
 
21331 
  thrift_spec = (
21332 
    None, # 0
21333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21334 
  )
21335 
 
21336 
  def __init__(self, ex=None,):
21337 
    self.ex = ex
21338 
 
21339 
  def read(self, iprot):
21340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21342 
      return
21343 
    iprot.readStructBegin()
21344 
    while True:
21345 
      (fname, ftype, fid) = iprot.readFieldBegin()
21346 
      if ftype == TType.STOP:
21347 
        break
21348 
      if fid == 1:
21349 
        if ftype == TType.STRUCT:
21350 
          self.ex = TransactionServiceException()
21351 
          self.ex.read(iprot)
21352 
        else:
21353 
          iprot.skip(ftype)
21354 
      else:
21355 
        iprot.skip(ftype)
21356 
      iprot.readFieldEnd()
21357 
    iprot.readStructEnd()
21358 
 
21359 
  def write(self, oprot):
21360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21362 
      return
21363 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21364 
    if self.ex is not None:
21365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21366 
      self.ex.write(oprot)
21367 
      oprot.writeFieldEnd()
21368 
    oprot.writeFieldStop()
21369 
    oprot.writeStructEnd()
21370 
 
21371 
  def validate(self):
21372 
    return
21373 
 
21374 
 
21375 
  def __repr__(self):
21376 
    L = ['%s=%r' % (key, value)
21377 
      for key, value in self.__dict__.iteritems()]
21378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21379 
 
21380 
  def __eq__(self, other):
21381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21382 
 
21383 
  def __ne__(self, other):
21384 
    return not (self == other)
4369 rajveer 21385 
 
21386 
class markOrdersAsTimeout_args:
21387 
  """
21388 
  Attributes:
21389 
   - vendorId
21390 
  """
21391 
 
21392 
  thrift_spec = (
21393 
    None, # 0
21394 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21395 
  )
21396 
 
21397 
  def __init__(self, vendorId=None,):
21398 
    self.vendorId = vendorId
21399 
 
21400 
  def read(self, iprot):
21401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21403 
      return
21404 
    iprot.readStructBegin()
21405 
    while True:
21406 
      (fname, ftype, fid) = iprot.readFieldBegin()
21407 
      if ftype == TType.STOP:
21408 
        break
21409 
      if fid == 1:
21410 
        if ftype == TType.I64:
21411 
          self.vendorId = iprot.readI64();
21412 
        else:
21413 
          iprot.skip(ftype)
21414 
      else:
21415 
        iprot.skip(ftype)
21416 
      iprot.readFieldEnd()
21417 
    iprot.readStructEnd()
21418 
 
21419 
  def write(self, oprot):
21420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21422 
      return
21423 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21424 
    if self.vendorId is not None:
21425 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21426 
      oprot.writeI64(self.vendorId)
21427 
      oprot.writeFieldEnd()
21428 
    oprot.writeFieldStop()
21429 
    oprot.writeStructEnd()
21430 
 
21431 
  def validate(self):
21432 
    return
21433 
 
21434 
 
21435 
  def __repr__(self):
21436 
    L = ['%s=%r' % (key, value)
21437 
      for key, value in self.__dict__.iteritems()]
21438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21439 
 
21440 
  def __eq__(self, other):
21441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21442 
 
21443 
  def __ne__(self, other):
21444 
    return not (self == other)
21445 
 
21446 
class markOrdersAsTimeout_result:
21447 
  """
21448 
  Attributes:
21449 
   - success
21450 
   - ex
21451 
  """
21452 
 
21453 
  thrift_spec = (
21454 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21455 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21456 
  )
21457 
 
21458 
  def __init__(self, success=None, ex=None,):
21459 
    self.success = success
21460 
    self.ex = ex
21461 
 
21462 
  def read(self, iprot):
21463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21465 
      return
21466 
    iprot.readStructBegin()
21467 
    while True:
21468 
      (fname, ftype, fid) = iprot.readFieldBegin()
21469 
      if ftype == TType.STOP:
21470 
        break
21471 
      if fid == 0:
21472 
        if ftype == TType.MAP:
21473 
          self.success = {}
6031 rajveer 21474 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
21475 
          for _i462 in xrange(_size458):
21476 
            _key463 = iprot.readI32();
21477 
            _val464 = TimeoutSummary()
21478 
            _val464.read(iprot)
21479 
            self.success[_key463] = _val464
4369 rajveer 21480 
          iprot.readMapEnd()
21481 
        else:
21482 
          iprot.skip(ftype)
21483 
      elif fid == 1:
21484 
        if ftype == TType.STRUCT:
21485 
          self.ex = TransactionServiceException()
21486 
          self.ex.read(iprot)
21487 
        else:
21488 
          iprot.skip(ftype)
21489 
      else:
21490 
        iprot.skip(ftype)
21491 
      iprot.readFieldEnd()
21492 
    iprot.readStructEnd()
21493 
 
21494 
  def write(self, oprot):
21495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21497 
      return
21498 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21499 
    if self.success is not None:
21500 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21501 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6031 rajveer 21502 
      for kiter465,viter466 in self.success.items():
21503 
        oprot.writeI32(kiter465)
21504 
        viter466.write(oprot)
4369 rajveer 21505 
      oprot.writeMapEnd()
21506 
      oprot.writeFieldEnd()
21507 
    if self.ex is not None:
21508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21509 
      self.ex.write(oprot)
21510 
      oprot.writeFieldEnd()
21511 
    oprot.writeFieldStop()
21512 
    oprot.writeStructEnd()
21513 
 
21514 
  def validate(self):
21515 
    return
21516 
 
21517 
 
21518 
  def __repr__(self):
21519 
    L = ['%s=%r' % (key, value)
21520 
      for key, value in self.__dict__.iteritems()]
21521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21522 
 
21523 
  def __eq__(self, other):
21524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21525 
 
21526 
  def __ne__(self, other):
21527 
    return not (self == other)
4386 anupam.sin 21528 
 
4662 rajveer 21529 
class markOrderAsLostInTransit_args:
21530 
  """
21531 
  Attributes:
21532 
   - orderId
21533 
  """
21534 
 
21535 
  thrift_spec = (
21536 
    None, # 0
21537 
    (1, TType.I64, 'orderId', None, None, ), # 1
21538 
  )
21539 
 
21540 
  def __init__(self, orderId=None,):
21541 
    self.orderId = orderId
21542 
 
21543 
  def read(self, iprot):
21544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21546 
      return
21547 
    iprot.readStructBegin()
21548 
    while True:
21549 
      (fname, ftype, fid) = iprot.readFieldBegin()
21550 
      if ftype == TType.STOP:
21551 
        break
21552 
      if fid == 1:
21553 
        if ftype == TType.I64:
21554 
          self.orderId = iprot.readI64();
21555 
        else:
21556 
          iprot.skip(ftype)
21557 
      else:
21558 
        iprot.skip(ftype)
21559 
      iprot.readFieldEnd()
21560 
    iprot.readStructEnd()
21561 
 
21562 
  def write(self, oprot):
21563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21565 
      return
21566 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21567 
    if self.orderId is not None:
21568 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21569 
      oprot.writeI64(self.orderId)
21570 
      oprot.writeFieldEnd()
21571 
    oprot.writeFieldStop()
21572 
    oprot.writeStructEnd()
21573 
 
21574 
  def validate(self):
21575 
    return
21576 
 
21577 
 
21578 
  def __repr__(self):
21579 
    L = ['%s=%r' % (key, value)
21580 
      for key, value in self.__dict__.iteritems()]
21581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21582 
 
21583 
  def __eq__(self, other):
21584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21585 
 
21586 
  def __ne__(self, other):
21587 
    return not (self == other)
21588 
 
21589 
class markOrderAsLostInTransit_result:
21590 
  """
21591 
  Attributes:
21592 
   - success
21593 
   - ex
21594 
  """
21595 
 
21596 
  thrift_spec = (
21597 
    (0, TType.BOOL, 'success', None, None, ), # 0
21598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21599 
  )
21600 
 
21601 
  def __init__(self, success=None, ex=None,):
21602 
    self.success = success
21603 
    self.ex = ex
21604 
 
21605 
  def read(self, iprot):
21606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21608 
      return
21609 
    iprot.readStructBegin()
21610 
    while True:
21611 
      (fname, ftype, fid) = iprot.readFieldBegin()
21612 
      if ftype == TType.STOP:
21613 
        break
21614 
      if fid == 0:
21615 
        if ftype == TType.BOOL:
21616 
          self.success = iprot.readBool();
21617 
        else:
21618 
          iprot.skip(ftype)
21619 
      elif fid == 1:
21620 
        if ftype == TType.STRUCT:
21621 
          self.ex = TransactionServiceException()
21622 
          self.ex.read(iprot)
21623 
        else:
21624 
          iprot.skip(ftype)
21625 
      else:
21626 
        iprot.skip(ftype)
21627 
      iprot.readFieldEnd()
21628 
    iprot.readStructEnd()
21629 
 
21630 
  def write(self, oprot):
21631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21633 
      return
21634 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21635 
    if self.success is not None:
21636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21637 
      oprot.writeBool(self.success)
21638 
      oprot.writeFieldEnd()
21639 
    if self.ex is not None:
21640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21641 
      self.ex.write(oprot)
21642 
      oprot.writeFieldEnd()
21643 
    oprot.writeFieldStop()
21644 
    oprot.writeStructEnd()
21645 
 
21646 
  def validate(self):
21647 
    return
21648 
 
21649 
 
21650 
  def __repr__(self):
21651 
    L = ['%s=%r' % (key, value)
21652 
      for key, value in self.__dict__.iteritems()]
21653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21654 
 
21655 
  def __eq__(self, other):
21656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21657 
 
21658 
  def __ne__(self, other):
21659 
    return not (self == other)
21660 
 
4386 anupam.sin 21661 
class getOrderForAwb_args:
21662 
  """
21663 
  Attributes:
21664 
   - awb
21665 
  """
21666 
 
21667 
  thrift_spec = (
21668 
    None, # 0
21669 
    (1, TType.STRING, 'awb', None, None, ), # 1
21670 
  )
21671 
 
21672 
  def __init__(self, awb=None,):
21673 
    self.awb = awb
21674 
 
21675 
  def read(self, iprot):
21676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21678 
      return
21679 
    iprot.readStructBegin()
21680 
    while True:
21681 
      (fname, ftype, fid) = iprot.readFieldBegin()
21682 
      if ftype == TType.STOP:
21683 
        break
21684 
      if fid == 1:
21685 
        if ftype == TType.STRING:
21686 
          self.awb = iprot.readString();
21687 
        else:
21688 
          iprot.skip(ftype)
21689 
      else:
21690 
        iprot.skip(ftype)
21691 
      iprot.readFieldEnd()
21692 
    iprot.readStructEnd()
21693 
 
21694 
  def write(self, oprot):
21695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21697 
      return
21698 
    oprot.writeStructBegin('getOrderForAwb_args')
21699 
    if self.awb is not None:
21700 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21701 
      oprot.writeString(self.awb)
21702 
      oprot.writeFieldEnd()
21703 
    oprot.writeFieldStop()
21704 
    oprot.writeStructEnd()
21705 
 
21706 
  def validate(self):
21707 
    return
21708 
 
21709 
 
21710 
  def __repr__(self):
21711 
    L = ['%s=%r' % (key, value)
21712 
      for key, value in self.__dict__.iteritems()]
21713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21714 
 
21715 
  def __eq__(self, other):
21716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21717 
 
21718 
  def __ne__(self, other):
21719 
    return not (self == other)
21720 
 
21721 
class getOrderForAwb_result:
21722 
  """
21723 
  Attributes:
21724 
   - success
21725 
   - ex
21726 
  """
21727 
 
21728 
  thrift_spec = (
21729 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21731 
  )
21732 
 
21733 
  def __init__(self, success=None, ex=None,):
21734 
    self.success = success
21735 
    self.ex = ex
21736 
 
21737 
  def read(self, iprot):
21738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21740 
      return
21741 
    iprot.readStructBegin()
21742 
    while True:
21743 
      (fname, ftype, fid) = iprot.readFieldBegin()
21744 
      if ftype == TType.STOP:
21745 
        break
21746 
      if fid == 0:
21747 
        if ftype == TType.STRUCT:
21748 
          self.success = Order()
21749 
          self.success.read(iprot)
21750 
        else:
21751 
          iprot.skip(ftype)
21752 
      elif fid == 1:
21753 
        if ftype == TType.STRUCT:
21754 
          self.ex = TransactionServiceException()
21755 
          self.ex.read(iprot)
21756 
        else:
21757 
          iprot.skip(ftype)
21758 
      else:
21759 
        iprot.skip(ftype)
21760 
      iprot.readFieldEnd()
21761 
    iprot.readStructEnd()
21762 
 
21763 
  def write(self, oprot):
21764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21766 
      return
21767 
    oprot.writeStructBegin('getOrderForAwb_result')
21768 
    if self.success is not None:
21769 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21770 
      self.success.write(oprot)
21771 
      oprot.writeFieldEnd()
21772 
    if self.ex is not None:
21773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21774 
      self.ex.write(oprot)
21775 
      oprot.writeFieldEnd()
21776 
    oprot.writeFieldStop()
21777 
    oprot.writeStructEnd()
21778 
 
21779 
  def validate(self):
21780 
    return
21781 
 
21782 
 
21783 
  def __repr__(self):
21784 
    L = ['%s=%r' % (key, value)
21785 
      for key, value in self.__dict__.iteritems()]
21786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21787 
 
21788 
  def __eq__(self, other):
21789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21790 
 
21791 
  def __ne__(self, other):
21792 
    return not (self == other)
4506 phani.kuma 21793 
 
21794 
class getOrdersForProviderForStatus_args:
21795 
  """
21796 
  Attributes:
21797 
   - logistics_provider_id
4910 phani.kuma 21798 
   - order_status_list
4506 phani.kuma 21799 
  """
21800 
 
21801 
  thrift_spec = (
21802 
    None, # 0
21803 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21804 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21805 
  )
21806 
 
4910 phani.kuma 21807 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21808 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21809 
    self.order_status_list = order_status_list
4506 phani.kuma 21810 
 
21811 
  def read(self, iprot):
21812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21814 
      return
21815 
    iprot.readStructBegin()
21816 
    while True:
21817 
      (fname, ftype, fid) = iprot.readFieldBegin()
21818 
      if ftype == TType.STOP:
21819 
        break
21820 
      if fid == 1:
21821 
        if ftype == TType.I64:
21822 
          self.logistics_provider_id = iprot.readI64();
21823 
        else:
21824 
          iprot.skip(ftype)
21825 
      elif fid == 2:
4910 phani.kuma 21826 
        if ftype == TType.LIST:
21827 
          self.order_status_list = []
6031 rajveer 21828 
          (_etype470, _size467) = iprot.readListBegin()
21829 
          for _i471 in xrange(_size467):
21830 
            _elem472 = iprot.readI32();
21831 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21832 
          iprot.readListEnd()
4506 phani.kuma 21833 
        else:
21834 
          iprot.skip(ftype)
21835 
      else:
21836 
        iprot.skip(ftype)
21837 
      iprot.readFieldEnd()
21838 
    iprot.readStructEnd()
21839 
 
21840 
  def write(self, oprot):
21841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21843 
      return
21844 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21845 
    if self.logistics_provider_id is not None:
21846 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21847 
      oprot.writeI64(self.logistics_provider_id)
21848 
      oprot.writeFieldEnd()
4910 phani.kuma 21849 
    if self.order_status_list is not None:
21850 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21851 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6031 rajveer 21852 
      for iter473 in self.order_status_list:
21853 
        oprot.writeI32(iter473)
4910 phani.kuma 21854 
      oprot.writeListEnd()
4506 phani.kuma 21855 
      oprot.writeFieldEnd()
21856 
    oprot.writeFieldStop()
21857 
    oprot.writeStructEnd()
21858 
 
21859 
  def validate(self):
21860 
    return
21861 
 
21862 
 
21863 
  def __repr__(self):
21864 
    L = ['%s=%r' % (key, value)
21865 
      for key, value in self.__dict__.iteritems()]
21866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21867 
 
21868 
  def __eq__(self, other):
21869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21870 
 
21871 
  def __ne__(self, other):
21872 
    return not (self == other)
21873 
 
21874 
class getOrdersForProviderForStatus_result:
21875 
  """
21876 
  Attributes:
21877 
   - success
21878 
   - ex
21879 
  """
21880 
 
21881 
  thrift_spec = (
21882 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21883 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21884 
  )
21885 
 
21886 
  def __init__(self, success=None, ex=None,):
21887 
    self.success = success
21888 
    self.ex = ex
21889 
 
21890 
  def read(self, iprot):
21891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21893 
      return
21894 
    iprot.readStructBegin()
21895 
    while True:
21896 
      (fname, ftype, fid) = iprot.readFieldBegin()
21897 
      if ftype == TType.STOP:
21898 
        break
21899 
      if fid == 0:
21900 
        if ftype == TType.LIST:
21901 
          self.success = []
6031 rajveer 21902 
          (_etype477, _size474) = iprot.readListBegin()
21903 
          for _i478 in xrange(_size474):
21904 
            _elem479 = Order()
21905 
            _elem479.read(iprot)
21906 
            self.success.append(_elem479)
4506 phani.kuma 21907 
          iprot.readListEnd()
21908 
        else:
21909 
          iprot.skip(ftype)
21910 
      elif fid == 1:
21911 
        if ftype == TType.STRUCT:
21912 
          self.ex = TransactionServiceException()
21913 
          self.ex.read(iprot)
21914 
        else:
21915 
          iprot.skip(ftype)
21916 
      else:
21917 
        iprot.skip(ftype)
21918 
      iprot.readFieldEnd()
21919 
    iprot.readStructEnd()
21920 
 
21921 
  def write(self, oprot):
21922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21924 
      return
21925 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21926 
    if self.success is not None:
21927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21929 
      for iter480 in self.success:
21930 
        iter480.write(oprot)
4506 phani.kuma 21931 
      oprot.writeListEnd()
21932 
      oprot.writeFieldEnd()
21933 
    if self.ex is not None:
21934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21935 
      self.ex.write(oprot)
21936 
      oprot.writeFieldEnd()
21937 
    oprot.writeFieldStop()
21938 
    oprot.writeStructEnd()
21939 
 
21940 
  def validate(self):
21941 
    return
21942 
 
21943 
 
21944 
  def __repr__(self):
21945 
    L = ['%s=%r' % (key, value)
21946 
      for key, value in self.__dict__.iteritems()]
21947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21948 
 
21949 
  def __eq__(self, other):
21950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21951 
 
21952 
  def __ne__(self, other):
21953 
    return not (self == other)
4600 varun.gupt 21954 
 
21955 
class getBilledOrdersForVendor_args:
21956 
  """
21957 
  Attributes:
21958 
   - vendorId
21959 
   - billingDateFrom
21960 
   - billingDateTo
21961 
  """
21962 
 
21963 
  thrift_spec = (
21964 
    None, # 0
21965 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21966 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21967 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21968 
  )
21969 
 
21970 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21971 
    self.vendorId = vendorId
21972 
    self.billingDateFrom = billingDateFrom
21973 
    self.billingDateTo = billingDateTo
21974 
 
21975 
  def read(self, iprot):
21976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21978 
      return
21979 
    iprot.readStructBegin()
21980 
    while True:
21981 
      (fname, ftype, fid) = iprot.readFieldBegin()
21982 
      if ftype == TType.STOP:
21983 
        break
21984 
      if fid == 1:
21985 
        if ftype == TType.I64:
21986 
          self.vendorId = iprot.readI64();
21987 
        else:
21988 
          iprot.skip(ftype)
21989 
      elif fid == 2:
21990 
        if ftype == TType.I64:
21991 
          self.billingDateFrom = iprot.readI64();
21992 
        else:
21993 
          iprot.skip(ftype)
21994 
      elif fid == 3:
21995 
        if ftype == TType.I64:
21996 
          self.billingDateTo = iprot.readI64();
21997 
        else:
21998 
          iprot.skip(ftype)
21999 
      else:
22000 
        iprot.skip(ftype)
22001 
      iprot.readFieldEnd()
22002 
    iprot.readStructEnd()
22003 
 
22004 
  def write(self, oprot):
22005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22007 
      return
22008 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22009 
    if self.vendorId is not None:
22010 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22011 
      oprot.writeI64(self.vendorId)
22012 
      oprot.writeFieldEnd()
22013 
    if self.billingDateFrom is not None:
22014 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22015 
      oprot.writeI64(self.billingDateFrom)
22016 
      oprot.writeFieldEnd()
22017 
    if self.billingDateTo is not None:
22018 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22019 
      oprot.writeI64(self.billingDateTo)
22020 
      oprot.writeFieldEnd()
22021 
    oprot.writeFieldStop()
22022 
    oprot.writeStructEnd()
22023 
 
22024 
  def validate(self):
22025 
    return
22026 
 
22027 
 
22028 
  def __repr__(self):
22029 
    L = ['%s=%r' % (key, value)
22030 
      for key, value in self.__dict__.iteritems()]
22031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22032 
 
22033 
  def __eq__(self, other):
22034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22035 
 
22036 
  def __ne__(self, other):
22037 
    return not (self == other)
22038 
 
22039 
class getBilledOrdersForVendor_result:
22040 
  """
22041 
  Attributes:
22042 
   - success
22043 
   - ex
22044 
  """
22045 
 
22046 
  thrift_spec = (
22047 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22048 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22049 
  )
22050 
 
22051 
  def __init__(self, success=None, ex=None,):
22052 
    self.success = success
22053 
    self.ex = ex
22054 
 
22055 
  def read(self, iprot):
22056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22058 
      return
22059 
    iprot.readStructBegin()
22060 
    while True:
22061 
      (fname, ftype, fid) = iprot.readFieldBegin()
22062 
      if ftype == TType.STOP:
22063 
        break
22064 
      if fid == 0:
22065 
        if ftype == TType.LIST:
22066 
          self.success = []
6031 rajveer 22067 
          (_etype484, _size481) = iprot.readListBegin()
22068 
          for _i485 in xrange(_size481):
22069 
            _elem486 = Order()
22070 
            _elem486.read(iprot)
22071 
            self.success.append(_elem486)
4600 varun.gupt 22072 
          iprot.readListEnd()
22073 
        else:
22074 
          iprot.skip(ftype)
22075 
      elif fid == 1:
22076 
        if ftype == TType.STRUCT:
22077 
          self.ex = TransactionServiceException()
22078 
          self.ex.read(iprot)
22079 
        else:
22080 
          iprot.skip(ftype)
22081 
      else:
22082 
        iprot.skip(ftype)
22083 
      iprot.readFieldEnd()
22084 
    iprot.readStructEnd()
22085 
 
22086 
  def write(self, oprot):
22087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22089 
      return
22090 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22091 
    if self.success is not None:
22092 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22093 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22094 
      for iter487 in self.success:
22095 
        iter487.write(oprot)
4600 varun.gupt 22096 
      oprot.writeListEnd()
22097 
      oprot.writeFieldEnd()
22098 
    if self.ex is not None:
22099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22100 
      self.ex.write(oprot)
22101 
      oprot.writeFieldEnd()
22102 
    oprot.writeFieldStop()
22103 
    oprot.writeStructEnd()
22104 
 
22105 
  def validate(self):
22106 
    return
22107 
 
22108 
 
22109 
  def __repr__(self):
22110 
    L = ['%s=%r' % (key, value)
22111 
      for key, value in self.__dict__.iteritems()]
22112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22113 
 
22114 
  def __eq__(self, other):
22115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22116 
 
22117 
  def __ne__(self, other):
22118 
    return not (self == other)
22119 
 
4607 rajveer 22120 
class getSlippedSippingDateOrders_args:
22121 
 
22122 
  thrift_spec = (
22123 
  )
22124 
 
22125 
  def read(self, iprot):
22126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22128 
      return
22129 
    iprot.readStructBegin()
22130 
    while True:
22131 
      (fname, ftype, fid) = iprot.readFieldBegin()
22132 
      if ftype == TType.STOP:
22133 
        break
22134 
      else:
22135 
        iprot.skip(ftype)
22136 
      iprot.readFieldEnd()
22137 
    iprot.readStructEnd()
22138 
 
22139 
  def write(self, oprot):
22140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22142 
      return
22143 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22144 
    oprot.writeFieldStop()
22145 
    oprot.writeStructEnd()
22146 
 
22147 
  def validate(self):
22148 
    return
22149 
 
22150 
 
22151 
  def __repr__(self):
22152 
    L = ['%s=%r' % (key, value)
22153 
      for key, value in self.__dict__.iteritems()]
22154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22155 
 
22156 
  def __eq__(self, other):
22157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22158 
 
22159 
  def __ne__(self, other):
22160 
    return not (self == other)
22161 
 
22162 
class getSlippedSippingDateOrders_result:
22163 
  """
22164 
  Attributes:
22165 
   - success
22166 
   - ex
22167 
  """
22168 
 
22169 
  thrift_spec = (
22170 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22172 
  )
22173 
 
22174 
  def __init__(self, success=None, ex=None,):
22175 
    self.success = success
22176 
    self.ex = ex
22177 
 
22178 
  def read(self, iprot):
22179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22181 
      return
22182 
    iprot.readStructBegin()
22183 
    while True:
22184 
      (fname, ftype, fid) = iprot.readFieldBegin()
22185 
      if ftype == TType.STOP:
22186 
        break
22187 
      if fid == 0:
22188 
        if ftype == TType.LIST:
22189 
          self.success = []
6031 rajveer 22190 
          (_etype491, _size488) = iprot.readListBegin()
22191 
          for _i492 in xrange(_size488):
22192 
            _elem493 = Order()
22193 
            _elem493.read(iprot)
22194 
            self.success.append(_elem493)
4607 rajveer 22195 
          iprot.readListEnd()
22196 
        else:
22197 
          iprot.skip(ftype)
22198 
      elif fid == 1:
22199 
        if ftype == TType.STRUCT:
22200 
          self.ex = TransactionServiceException()
22201 
          self.ex.read(iprot)
22202 
        else:
22203 
          iprot.skip(ftype)
22204 
      else:
22205 
        iprot.skip(ftype)
22206 
      iprot.readFieldEnd()
22207 
    iprot.readStructEnd()
22208 
 
22209 
  def write(self, oprot):
22210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22212 
      return
22213 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22214 
    if self.success is not None:
22215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22217 
      for iter494 in self.success:
22218 
        iter494.write(oprot)
4607 rajveer 22219 
      oprot.writeListEnd()
22220 
      oprot.writeFieldEnd()
22221 
    if self.ex is not None:
22222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22223 
      self.ex.write(oprot)
22224 
      oprot.writeFieldEnd()
22225 
    oprot.writeFieldStop()
22226 
    oprot.writeStructEnd()
22227 
 
22228 
  def validate(self):
22229 
    return
22230 
 
22231 
 
22232 
  def __repr__(self):
22233 
    L = ['%s=%r' % (key, value)
22234 
      for key, value in self.__dict__.iteritems()]
22235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22236 
 
22237 
  def __eq__(self, other):
22238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22239 
 
22240 
  def __ne__(self, other):
22241 
    return not (self == other)
22242 
 
4709 rajveer 22243 
class getCancelledOrders_args:
22244 
  """
22245 
  Attributes:
22246 
   - cancelDateFrom
22247 
   - cancelDateTo
22248 
  """
22249 
 
22250 
  thrift_spec = (
22251 
    None, # 0
22252 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22253 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22254 
  )
22255 
 
22256 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22257 
    self.cancelDateFrom = cancelDateFrom
22258 
    self.cancelDateTo = cancelDateTo
22259 
 
22260 
  def read(self, iprot):
22261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22263 
      return
22264 
    iprot.readStructBegin()
22265 
    while True:
22266 
      (fname, ftype, fid) = iprot.readFieldBegin()
22267 
      if ftype == TType.STOP:
22268 
        break
22269 
      if fid == 1:
22270 
        if ftype == TType.I64:
22271 
          self.cancelDateFrom = iprot.readI64();
22272 
        else:
22273 
          iprot.skip(ftype)
22274 
      elif fid == 2:
22275 
        if ftype == TType.I64:
22276 
          self.cancelDateTo = iprot.readI64();
22277 
        else:
22278 
          iprot.skip(ftype)
22279 
      else:
22280 
        iprot.skip(ftype)
22281 
      iprot.readFieldEnd()
22282 
    iprot.readStructEnd()
22283 
 
22284 
  def write(self, oprot):
22285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22287 
      return
22288 
    oprot.writeStructBegin('getCancelledOrders_args')
22289 
    if self.cancelDateFrom is not None:
22290 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22291 
      oprot.writeI64(self.cancelDateFrom)
22292 
      oprot.writeFieldEnd()
22293 
    if self.cancelDateTo is not None:
22294 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22295 
      oprot.writeI64(self.cancelDateTo)
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 getCancelledOrders_result:
22316 
  """
22317 
  Attributes:
22318 
   - success
22319 
   - ex
22320 
  """
22321 
 
22322 
  thrift_spec = (
22323 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22325 
  )
22326 
 
22327 
  def __init__(self, success=None, ex=None,):
22328 
    self.success = success
22329 
    self.ex = ex
22330 
 
22331 
  def read(self, iprot):
22332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22334 
      return
22335 
    iprot.readStructBegin()
22336 
    while True:
22337 
      (fname, ftype, fid) = iprot.readFieldBegin()
22338 
      if ftype == TType.STOP:
22339 
        break
22340 
      if fid == 0:
22341 
        if ftype == TType.LIST:
22342 
          self.success = []
6031 rajveer 22343 
          (_etype498, _size495) = iprot.readListBegin()
22344 
          for _i499 in xrange(_size495):
22345 
            _elem500 = Order()
22346 
            _elem500.read(iprot)
22347 
            self.success.append(_elem500)
4709 rajveer 22348 
          iprot.readListEnd()
22349 
        else:
22350 
          iprot.skip(ftype)
22351 
      elif fid == 1:
22352 
        if ftype == TType.STRUCT:
22353 
          self.ex = TransactionServiceException()
22354 
          self.ex.read(iprot)
22355 
        else:
22356 
          iprot.skip(ftype)
22357 
      else:
22358 
        iprot.skip(ftype)
22359 
      iprot.readFieldEnd()
22360 
    iprot.readStructEnd()
22361 
 
22362 
  def write(self, oprot):
22363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22365 
      return
22366 
    oprot.writeStructBegin('getCancelledOrders_result')
22367 
    if self.success is not None:
22368 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22369 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22370 
      for iter501 in self.success:
22371 
        iter501.write(oprot)
4709 rajveer 22372 
      oprot.writeListEnd()
22373 
      oprot.writeFieldEnd()
22374 
    if self.ex is not None:
22375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22376 
      self.ex.write(oprot)
22377 
      oprot.writeFieldEnd()
22378 
    oprot.writeFieldStop()
22379 
    oprot.writeStructEnd()
22380 
 
22381 
  def validate(self):
22382 
    return
22383 
 
22384 
 
22385 
  def __repr__(self):
22386 
    L = ['%s=%r' % (key, value)
22387 
      for key, value in self.__dict__.iteritems()]
22388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22389 
 
22390 
  def __eq__(self, other):
22391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22392 
 
22393 
  def __ne__(self, other):
22394 
    return not (self == other)
22395 
 
4600 varun.gupt 22396 
class saveBluedartSettlements_args:
22397 
  """
22398 
  Attributes:
22399 
   - mapAWBAndAmount
22400 
  """
22401 
 
22402 
  thrift_spec = (
22403 
    None, # 0
22404 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22405 
  )
22406 
 
22407 
  def __init__(self, mapAWBAndAmount=None,):
22408 
    self.mapAWBAndAmount = mapAWBAndAmount
22409 
 
22410 
  def read(self, iprot):
22411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22413 
      return
22414 
    iprot.readStructBegin()
22415 
    while True:
22416 
      (fname, ftype, fid) = iprot.readFieldBegin()
22417 
      if ftype == TType.STOP:
22418 
        break
22419 
      if fid == 1:
22420 
        if ftype == TType.MAP:
22421 
          self.mapAWBAndAmount = {}
6031 rajveer 22422 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
22423 
          for _i506 in xrange(_size502):
22424 
            _key507 = iprot.readI64();
22425 
            _val508 = iprot.readDouble();
22426 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 22427 
          iprot.readMapEnd()
22428 
        else:
22429 
          iprot.skip(ftype)
22430 
      else:
22431 
        iprot.skip(ftype)
22432 
      iprot.readFieldEnd()
22433 
    iprot.readStructEnd()
22434 
 
22435 
  def write(self, oprot):
22436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22438 
      return
22439 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22440 
    if self.mapAWBAndAmount is not None:
22441 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22442 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6031 rajveer 22443 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
22444 
        oprot.writeI64(kiter509)
22445 
        oprot.writeDouble(viter510)
4600 varun.gupt 22446 
      oprot.writeMapEnd()
22447 
      oprot.writeFieldEnd()
22448 
    oprot.writeFieldStop()
22449 
    oprot.writeStructEnd()
22450 
 
22451 
  def validate(self):
22452 
    return
22453 
 
22454 
 
22455 
  def __repr__(self):
22456 
    L = ['%s=%r' % (key, value)
22457 
      for key, value in self.__dict__.iteritems()]
22458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22459 
 
22460 
  def __eq__(self, other):
22461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22462 
 
22463 
  def __ne__(self, other):
22464 
    return not (self == other)
22465 
 
22466 
class saveBluedartSettlements_result:
22467 
  """
22468 
  Attributes:
22469 
   - ex
22470 
  """
22471 
 
22472 
  thrift_spec = (
22473 
    None, # 0
22474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22475 
  )
22476 
 
22477 
  def __init__(self, ex=None,):
22478 
    self.ex = ex
22479 
 
22480 
  def read(self, iprot):
22481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22483 
      return
22484 
    iprot.readStructBegin()
22485 
    while True:
22486 
      (fname, ftype, fid) = iprot.readFieldBegin()
22487 
      if ftype == TType.STOP:
22488 
        break
22489 
      if fid == 1:
22490 
        if ftype == TType.STRUCT:
22491 
          self.ex = TransactionServiceException()
22492 
          self.ex.read(iprot)
22493 
        else:
22494 
          iprot.skip(ftype)
22495 
      else:
22496 
        iprot.skip(ftype)
22497 
      iprot.readFieldEnd()
22498 
    iprot.readStructEnd()
22499 
 
22500 
  def write(self, oprot):
22501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22503 
      return
22504 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22505 
    if self.ex is not None:
22506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22507 
      self.ex.write(oprot)
22508 
      oprot.writeFieldEnd()
22509 
    oprot.writeFieldStop()
22510 
    oprot.writeStructEnd()
22511 
 
22512 
  def validate(self):
22513 
    return
22514 
 
22515 
 
22516 
  def __repr__(self):
22517 
    L = ['%s=%r' % (key, value)
22518 
      for key, value in self.__dict__.iteritems()]
22519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22520 
 
22521 
  def __eq__(self, other):
22522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22523 
 
22524 
  def __ne__(self, other):
22525 
    return not (self == other)
22526 
 
22527 
class savePaymentSettlements_args:
22528 
  """
22529 
  Attributes:
22530 
   - settlementDate
22531 
   - paymentGatewayId
4905 varun.gupt 22532 
   - referenceId
4600 varun.gupt 22533 
   - serviceTax
22534 
   - otherCharges
22535 
   - netCollection
22536 
  """
22537 
 
22538 
  thrift_spec = (
22539 
    None, # 0
22540 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22541 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22542 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22543 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22544 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22545 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22546 
  )
22547 
 
4905 varun.gupt 22548 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22549 
    self.settlementDate = settlementDate
22550 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22551 
    self.referenceId = referenceId
4600 varun.gupt 22552 
    self.serviceTax = serviceTax
22553 
    self.otherCharges = otherCharges
22554 
    self.netCollection = netCollection
22555 
 
22556 
  def read(self, iprot):
22557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22559 
      return
22560 
    iprot.readStructBegin()
22561 
    while True:
22562 
      (fname, ftype, fid) = iprot.readFieldBegin()
22563 
      if ftype == TType.STOP:
22564 
        break
22565 
      if fid == 1:
22566 
        if ftype == TType.I64:
22567 
          self.settlementDate = iprot.readI64();
22568 
        else:
22569 
          iprot.skip(ftype)
22570 
      elif fid == 2:
22571 
        if ftype == TType.I64:
22572 
          self.paymentGatewayId = iprot.readI64();
22573 
        else:
22574 
          iprot.skip(ftype)
22575 
      elif fid == 3:
22576 
        if ftype == TType.I64:
4905 varun.gupt 22577 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22578 
        else:
22579 
          iprot.skip(ftype)
22580 
      elif fid == 4:
22581 
        if ftype == TType.DOUBLE:
22582 
          self.serviceTax = iprot.readDouble();
22583 
        else:
22584 
          iprot.skip(ftype)
22585 
      elif fid == 5:
22586 
        if ftype == TType.DOUBLE:
22587 
          self.otherCharges = iprot.readDouble();
22588 
        else:
22589 
          iprot.skip(ftype)
22590 
      elif fid == 6:
22591 
        if ftype == TType.DOUBLE:
22592 
          self.netCollection = iprot.readDouble();
22593 
        else:
22594 
          iprot.skip(ftype)
22595 
      else:
22596 
        iprot.skip(ftype)
22597 
      iprot.readFieldEnd()
22598 
    iprot.readStructEnd()
22599 
 
22600 
  def write(self, oprot):
22601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22603 
      return
22604 
    oprot.writeStructBegin('savePaymentSettlements_args')
22605 
    if self.settlementDate is not None:
22606 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22607 
      oprot.writeI64(self.settlementDate)
22608 
      oprot.writeFieldEnd()
22609 
    if self.paymentGatewayId is not None:
22610 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22611 
      oprot.writeI64(self.paymentGatewayId)
22612 
      oprot.writeFieldEnd()
4905 varun.gupt 22613 
    if self.referenceId is not None:
22614 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22615 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22616 
      oprot.writeFieldEnd()
22617 
    if self.serviceTax is not None:
22618 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22619 
      oprot.writeDouble(self.serviceTax)
22620 
      oprot.writeFieldEnd()
22621 
    if self.otherCharges is not None:
22622 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22623 
      oprot.writeDouble(self.otherCharges)
22624 
      oprot.writeFieldEnd()
22625 
    if self.netCollection is not None:
22626 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22627 
      oprot.writeDouble(self.netCollection)
22628 
      oprot.writeFieldEnd()
22629 
    oprot.writeFieldStop()
22630 
    oprot.writeStructEnd()
22631 
 
22632 
  def validate(self):
22633 
    return
22634 
 
22635 
 
22636 
  def __repr__(self):
22637 
    L = ['%s=%r' % (key, value)
22638 
      for key, value in self.__dict__.iteritems()]
22639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22640 
 
22641 
  def __eq__(self, other):
22642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22643 
 
22644 
  def __ne__(self, other):
22645 
    return not (self == other)
22646 
 
22647 
class savePaymentSettlements_result:
22648 
  """
22649 
  Attributes:
22650 
   - ex
22651 
  """
22652 
 
22653 
  thrift_spec = (
22654 
    None, # 0
22655 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22656 
  )
22657 
 
22658 
  def __init__(self, ex=None,):
22659 
    self.ex = ex
22660 
 
22661 
  def read(self, iprot):
22662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22664 
      return
22665 
    iprot.readStructBegin()
22666 
    while True:
22667 
      (fname, ftype, fid) = iprot.readFieldBegin()
22668 
      if ftype == TType.STOP:
22669 
        break
22670 
      if fid == 1:
22671 
        if ftype == TType.STRUCT:
22672 
          self.ex = TransactionServiceException()
22673 
          self.ex.read(iprot)
22674 
        else:
22675 
          iprot.skip(ftype)
22676 
      else:
22677 
        iprot.skip(ftype)
22678 
      iprot.readFieldEnd()
22679 
    iprot.readStructEnd()
22680 
 
22681 
  def write(self, oprot):
22682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22684 
      return
22685 
    oprot.writeStructBegin('savePaymentSettlements_result')
22686 
    if self.ex is not None:
22687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22688 
      self.ex.write(oprot)
22689 
      oprot.writeFieldEnd()
22690 
    oprot.writeFieldStop()
22691 
    oprot.writeStructEnd()
22692 
 
22693 
  def validate(self):
22694 
    return
22695 
 
22696 
 
22697 
  def __repr__(self):
22698 
    L = ['%s=%r' % (key, value)
22699 
      for key, value in self.__dict__.iteritems()]
22700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22701 
 
22702 
  def __eq__(self, other):
22703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22704 
 
22705 
  def __ne__(self, other):
22706 
    return not (self == other)
22707 
 
22708 
class saveEBSSettlementSummary_args:
22709 
  """
22710 
  Attributes:
22711 
   - settlementId
22712 
   - settlementDate
22713 
   - transactionDateFrom
22714 
   - transactionDateTo
22715 
   - amount
22716 
  """
22717 
 
22718 
  thrift_spec = (
22719 
    None, # 0
22720 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22721 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22722 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22723 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22724 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22725 
  )
22726 
 
22727 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22728 
    self.settlementId = settlementId
22729 
    self.settlementDate = settlementDate
22730 
    self.transactionDateFrom = transactionDateFrom
22731 
    self.transactionDateTo = transactionDateTo
22732 
    self.amount = amount
22733 
 
22734 
  def read(self, iprot):
22735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22737 
      return
22738 
    iprot.readStructBegin()
22739 
    while True:
22740 
      (fname, ftype, fid) = iprot.readFieldBegin()
22741 
      if ftype == TType.STOP:
22742 
        break
22743 
      if fid == 1:
22744 
        if ftype == TType.I64:
22745 
          self.settlementId = iprot.readI64();
22746 
        else:
22747 
          iprot.skip(ftype)
22748 
      elif fid == 2:
22749 
        if ftype == TType.I64:
22750 
          self.settlementDate = iprot.readI64();
22751 
        else:
22752 
          iprot.skip(ftype)
22753 
      elif fid == 3:
22754 
        if ftype == TType.I64:
22755 
          self.transactionDateFrom = iprot.readI64();
22756 
        else:
22757 
          iprot.skip(ftype)
22758 
      elif fid == 4:
22759 
        if ftype == TType.I64:
22760 
          self.transactionDateTo = iprot.readI64();
22761 
        else:
22762 
          iprot.skip(ftype)
22763 
      elif fid == 5:
22764 
        if ftype == TType.DOUBLE:
22765 
          self.amount = iprot.readDouble();
22766 
        else:
22767 
          iprot.skip(ftype)
22768 
      else:
22769 
        iprot.skip(ftype)
22770 
      iprot.readFieldEnd()
22771 
    iprot.readStructEnd()
22772 
 
22773 
  def write(self, oprot):
22774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22776 
      return
22777 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22778 
    if self.settlementId is not None:
22779 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22780 
      oprot.writeI64(self.settlementId)
22781 
      oprot.writeFieldEnd()
22782 
    if self.settlementDate is not None:
22783 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22784 
      oprot.writeI64(self.settlementDate)
22785 
      oprot.writeFieldEnd()
22786 
    if self.transactionDateFrom is not None:
22787 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22788 
      oprot.writeI64(self.transactionDateFrom)
22789 
      oprot.writeFieldEnd()
22790 
    if self.transactionDateTo is not None:
22791 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22792 
      oprot.writeI64(self.transactionDateTo)
22793 
      oprot.writeFieldEnd()
22794 
    if self.amount is not None:
22795 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22796 
      oprot.writeDouble(self.amount)
22797 
      oprot.writeFieldEnd()
22798 
    oprot.writeFieldStop()
22799 
    oprot.writeStructEnd()
22800 
 
22801 
  def validate(self):
22802 
    return
22803 
 
22804 
 
22805 
  def __repr__(self):
22806 
    L = ['%s=%r' % (key, value)
22807 
      for key, value in self.__dict__.iteritems()]
22808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22809 
 
22810 
  def __eq__(self, other):
22811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22812 
 
22813 
  def __ne__(self, other):
22814 
    return not (self == other)
22815 
 
22816 
class saveEBSSettlementSummary_result:
22817 
  """
22818 
  Attributes:
22819 
   - ex
22820 
  """
22821 
 
22822 
  thrift_spec = (
22823 
    None, # 0
22824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22825 
  )
22826 
 
22827 
  def __init__(self, ex=None,):
22828 
    self.ex = ex
22829 
 
22830 
  def read(self, iprot):
22831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22833 
      return
22834 
    iprot.readStructBegin()
22835 
    while True:
22836 
      (fname, ftype, fid) = iprot.readFieldBegin()
22837 
      if ftype == TType.STOP:
22838 
        break
22839 
      if fid == 1:
22840 
        if ftype == TType.STRUCT:
22841 
          self.ex = TransactionServiceException()
22842 
          self.ex.read(iprot)
22843 
        else:
22844 
          iprot.skip(ftype)
22845 
      else:
22846 
        iprot.skip(ftype)
22847 
      iprot.readFieldEnd()
22848 
    iprot.readStructEnd()
22849 
 
22850 
  def write(self, oprot):
22851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22853 
      return
22854 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22855 
    if self.ex is not None:
22856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22857 
      self.ex.write(oprot)
22858 
      oprot.writeFieldEnd()
22859 
    oprot.writeFieldStop()
22860 
    oprot.writeStructEnd()
22861 
 
22862 
  def validate(self):
22863 
    return
22864 
 
22865 
 
22866 
  def __repr__(self):
22867 
    L = ['%s=%r' % (key, value)
22868 
      for key, value in self.__dict__.iteritems()]
22869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22870 
 
22871 
  def __eq__(self, other):
22872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22873 
 
22874 
  def __ne__(self, other):
22875 
    return not (self == other)
22876 
 
5386 phani.kuma 22877 
class getSettlementForPrepaid_args:
4600 varun.gupt 22878 
  """
22879 
  Attributes:
5189 varun.gupt 22880 
   - referenceId
22881 
   - isRefund
4600 varun.gupt 22882 
  """
22883 
 
22884 
  thrift_spec = (
22885 
    None, # 0
5189 varun.gupt 22886 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22887 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22888 
  )
22889 
 
5386 phani.kuma 22890 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22891 
    self.referenceId = referenceId
22892 
    self.isRefund = isRefund
4600 varun.gupt 22893 
 
22894 
  def read(self, iprot):
22895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22897 
      return
22898 
    iprot.readStructBegin()
22899 
    while True:
22900 
      (fname, ftype, fid) = iprot.readFieldBegin()
22901 
      if ftype == TType.STOP:
22902 
        break
22903 
      if fid == 1:
22904 
        if ftype == TType.I64:
5189 varun.gupt 22905 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22906 
        else:
22907 
          iprot.skip(ftype)
5189 varun.gupt 22908 
      elif fid == 2:
22909 
        if ftype == TType.BOOL:
22910 
          self.isRefund = iprot.readBool();
22911 
        else:
22912 
          iprot.skip(ftype)
4600 varun.gupt 22913 
      else:
22914 
        iprot.skip(ftype)
22915 
      iprot.readFieldEnd()
22916 
    iprot.readStructEnd()
22917 
 
22918 
  def write(self, oprot):
22919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22921 
      return
5386 phani.kuma 22922 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22923 
    if self.referenceId is not None:
22924 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22925 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22926 
      oprot.writeFieldEnd()
5386 phani.kuma 22927 
    if self.isRefund is not None:
22928 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22929 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22930 
      oprot.writeFieldEnd()
5386 phani.kuma 22931 
    oprot.writeFieldStop()
22932 
    oprot.writeStructEnd()
22933 
 
22934 
  def validate(self):
22935 
    return
22936 
 
22937 
 
22938 
  def __repr__(self):
22939 
    L = ['%s=%r' % (key, value)
22940 
      for key, value in self.__dict__.iteritems()]
22941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22942 
 
22943 
  def __eq__(self, other):
22944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22945 
 
22946 
  def __ne__(self, other):
22947 
    return not (self == other)
22948 
 
22949 
class getSettlementForPrepaid_result:
22950 
  """
22951 
  Attributes:
22952 
   - success
22953 
   - ex
22954 
  """
22955 
 
22956 
  thrift_spec = (
22957 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22959 
  )
22960 
 
22961 
  def __init__(self, success=None, ex=None,):
22962 
    self.success = success
22963 
    self.ex = ex
22964 
 
22965 
  def read(self, iprot):
22966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22968 
      return
22969 
    iprot.readStructBegin()
22970 
    while True:
22971 
      (fname, ftype, fid) = iprot.readFieldBegin()
22972 
      if ftype == TType.STOP:
22973 
        break
22974 
      if fid == 0:
22975 
        if ftype == TType.STRUCT:
22976 
          self.success = PaymentSettlement()
22977 
          self.success.read(iprot)
22978 
        else:
22979 
          iprot.skip(ftype)
22980 
      elif fid == 1:
22981 
        if ftype == TType.STRUCT:
22982 
          self.ex = TransactionServiceException()
22983 
          self.ex.read(iprot)
22984 
        else:
22985 
          iprot.skip(ftype)
22986 
      else:
22987 
        iprot.skip(ftype)
22988 
      iprot.readFieldEnd()
22989 
    iprot.readStructEnd()
22990 
 
22991 
  def write(self, oprot):
22992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22994 
      return
22995 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22996 
    if self.success is not None:
22997 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22998 
      self.success.write(oprot)
22999 
      oprot.writeFieldEnd()
23000 
    if self.ex is not None:
23001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23002 
      self.ex.write(oprot)
23003 
      oprot.writeFieldEnd()
23004 
    oprot.writeFieldStop()
23005 
    oprot.writeStructEnd()
23006 
 
23007 
  def validate(self):
23008 
    return
23009 
 
23010 
 
23011 
  def __repr__(self):
23012 
    L = ['%s=%r' % (key, value)
23013 
      for key, value in self.__dict__.iteritems()]
23014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23015 
 
23016 
  def __eq__(self, other):
23017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23018 
 
23019 
  def __ne__(self, other):
23020 
    return not (self == other)
23021 
 
23022 
class getSettlementForCod_args:
23023 
  """
23024 
  Attributes:
23025 
   - orderId
23026 
   - isRefund
23027 
  """
23028 
 
23029 
  thrift_spec = (
23030 
    None, # 0
23031 
    (1, TType.I64, 'orderId', None, None, ), # 1
23032 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23033 
  )
23034 
 
23035 
  def __init__(self, orderId=None, isRefund=None,):
23036 
    self.orderId = orderId
23037 
    self.isRefund = isRefund
23038 
 
23039 
  def read(self, iprot):
23040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23042 
      return
23043 
    iprot.readStructBegin()
23044 
    while True:
23045 
      (fname, ftype, fid) = iprot.readFieldBegin()
23046 
      if ftype == TType.STOP:
23047 
        break
23048 
      if fid == 1:
23049 
        if ftype == TType.I64:
23050 
          self.orderId = iprot.readI64();
23051 
        else:
23052 
          iprot.skip(ftype)
23053 
      elif fid == 2:
23054 
        if ftype == TType.BOOL:
23055 
          self.isRefund = iprot.readBool();
23056 
        else:
23057 
          iprot.skip(ftype)
23058 
      else:
23059 
        iprot.skip(ftype)
23060 
      iprot.readFieldEnd()
23061 
    iprot.readStructEnd()
23062 
 
23063 
  def write(self, oprot):
23064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23066 
      return
23067 
    oprot.writeStructBegin('getSettlementForCod_args')
23068 
    if self.orderId is not None:
23069 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23070 
      oprot.writeI64(self.orderId)
23071 
      oprot.writeFieldEnd()
5189 varun.gupt 23072 
    if self.isRefund is not None:
5386 phani.kuma 23073 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23074 
      oprot.writeBool(self.isRefund)
23075 
      oprot.writeFieldEnd()
4600 varun.gupt 23076 
    oprot.writeFieldStop()
23077 
    oprot.writeStructEnd()
23078 
 
23079 
  def validate(self):
23080 
    return
23081 
 
23082 
 
23083 
  def __repr__(self):
23084 
    L = ['%s=%r' % (key, value)
23085 
      for key, value in self.__dict__.iteritems()]
23086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23087 
 
23088 
  def __eq__(self, other):
23089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23090 
 
23091 
  def __ne__(self, other):
23092 
    return not (self == other)
23093 
 
5386 phani.kuma 23094 
class getSettlementForCod_result:
4600 varun.gupt 23095 
  """
23096 
  Attributes:
23097 
   - success
23098 
   - ex
23099 
  """
23100 
 
23101 
  thrift_spec = (
23102 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23103 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23104 
  )
23105 
 
23106 
  def __init__(self, success=None, ex=None,):
23107 
    self.success = success
23108 
    self.ex = ex
23109 
 
23110 
  def read(self, iprot):
23111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23113 
      return
23114 
    iprot.readStructBegin()
23115 
    while True:
23116 
      (fname, ftype, fid) = iprot.readFieldBegin()
23117 
      if ftype == TType.STOP:
23118 
        break
23119 
      if fid == 0:
23120 
        if ftype == TType.STRUCT:
23121 
          self.success = PaymentSettlement()
23122 
          self.success.read(iprot)
23123 
        else:
23124 
          iprot.skip(ftype)
23125 
      elif fid == 1:
23126 
        if ftype == TType.STRUCT:
23127 
          self.ex = TransactionServiceException()
23128 
          self.ex.read(iprot)
23129 
        else:
23130 
          iprot.skip(ftype)
23131 
      else:
23132 
        iprot.skip(ftype)
23133 
      iprot.readFieldEnd()
23134 
    iprot.readStructEnd()
23135 
 
23136 
  def write(self, oprot):
23137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23139 
      return
5386 phani.kuma 23140 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23141 
    if self.success is not None:
23142 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23143 
      self.success.write(oprot)
23144 
      oprot.writeFieldEnd()
23145 
    if self.ex is not None:
23146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23147 
      self.ex.write(oprot)
23148 
      oprot.writeFieldEnd()
23149 
    oprot.writeFieldStop()
23150 
    oprot.writeStructEnd()
23151 
 
23152 
  def validate(self):
23153 
    return
23154 
 
23155 
 
23156 
  def __repr__(self):
23157 
    L = ['%s=%r' % (key, value)
23158 
      for key, value in self.__dict__.iteritems()]
23159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23160 
 
23161 
  def __eq__(self, other):
23162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23163 
 
23164 
  def __ne__(self, other):
23165 
    return not (self == other)
23166 
 
23167 
class getEBSSettlementSummaries_args:
23168 
 
23169 
  thrift_spec = (
23170 
  )
23171 
 
23172 
  def read(self, iprot):
23173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23175 
      return
23176 
    iprot.readStructBegin()
23177 
    while True:
23178 
      (fname, ftype, fid) = iprot.readFieldBegin()
23179 
      if ftype == TType.STOP:
23180 
        break
23181 
      else:
23182 
        iprot.skip(ftype)
23183 
      iprot.readFieldEnd()
23184 
    iprot.readStructEnd()
23185 
 
23186 
  def write(self, oprot):
23187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23189 
      return
23190 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23191 
    oprot.writeFieldStop()
23192 
    oprot.writeStructEnd()
23193 
 
23194 
  def validate(self):
23195 
    return
23196 
 
23197 
 
23198 
  def __repr__(self):
23199 
    L = ['%s=%r' % (key, value)
23200 
      for key, value in self.__dict__.iteritems()]
23201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23202 
 
23203 
  def __eq__(self, other):
23204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23205 
 
23206 
  def __ne__(self, other):
23207 
    return not (self == other)
23208 
 
23209 
class getEBSSettlementSummaries_result:
23210 
  """
23211 
  Attributes:
23212 
   - success
23213 
   - ex
23214 
  """
23215 
 
23216 
  thrift_spec = (
23217 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23219 
  )
23220 
 
23221 
  def __init__(self, success=None, ex=None,):
23222 
    self.success = success
23223 
    self.ex = ex
23224 
 
23225 
  def read(self, iprot):
23226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23228 
      return
23229 
    iprot.readStructBegin()
23230 
    while True:
23231 
      (fname, ftype, fid) = iprot.readFieldBegin()
23232 
      if ftype == TType.STOP:
23233 
        break
23234 
      if fid == 0:
23235 
        if ftype == TType.MAP:
23236 
          self.success = {}
6031 rajveer 23237 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
23238 
          for _i515 in xrange(_size511):
23239 
            _key516 = iprot.readI64();
23240 
            _val517 = iprot.readString();
23241 
            self.success[_key516] = _val517
4600 varun.gupt 23242 
          iprot.readMapEnd()
23243 
        else:
23244 
          iprot.skip(ftype)
23245 
      elif fid == 1:
23246 
        if ftype == TType.STRUCT:
23247 
          self.ex = TransactionServiceException()
23248 
          self.ex.read(iprot)
23249 
        else:
23250 
          iprot.skip(ftype)
23251 
      else:
23252 
        iprot.skip(ftype)
23253 
      iprot.readFieldEnd()
23254 
    iprot.readStructEnd()
23255 
 
23256 
  def write(self, oprot):
23257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23259 
      return
23260 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23261 
    if self.success is not None:
23262 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23263 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6031 rajveer 23264 
      for kiter518,viter519 in self.success.items():
23265 
        oprot.writeI64(kiter518)
23266 
        oprot.writeString(viter519)
4600 varun.gupt 23267 
      oprot.writeMapEnd()
23268 
      oprot.writeFieldEnd()
23269 
    if self.ex is not None:
23270 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23271 
      self.ex.write(oprot)
23272 
      oprot.writeFieldEnd()
23273 
    oprot.writeFieldStop()
23274 
    oprot.writeStructEnd()
23275 
 
23276 
  def validate(self):
23277 
    return
23278 
 
23279 
 
23280 
  def __repr__(self):
23281 
    L = ['%s=%r' % (key, value)
23282 
      for key, value in self.__dict__.iteritems()]
23283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23284 
 
23285 
  def __eq__(self, other):
23286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23287 
 
23288 
  def __ne__(self, other):
23289 
    return not (self == other)
23290 
 
23291 
class markEBSSettlementUploaded_args:
23292 
  """
23293 
  Attributes:
23294 
   - settlementId
23295 
  """
23296 
 
23297 
  thrift_spec = (
23298 
    None, # 0
23299 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23300 
  )
23301 
 
23302 
  def __init__(self, settlementId=None,):
23303 
    self.settlementId = settlementId
23304 
 
23305 
  def read(self, iprot):
23306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23308 
      return
23309 
    iprot.readStructBegin()
23310 
    while True:
23311 
      (fname, ftype, fid) = iprot.readFieldBegin()
23312 
      if ftype == TType.STOP:
23313 
        break
23314 
      if fid == 1:
23315 
        if ftype == TType.I64:
23316 
          self.settlementId = iprot.readI64();
23317 
        else:
23318 
          iprot.skip(ftype)
23319 
      else:
23320 
        iprot.skip(ftype)
23321 
      iprot.readFieldEnd()
23322 
    iprot.readStructEnd()
23323 
 
23324 
  def write(self, oprot):
23325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23327 
      return
23328 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23329 
    if self.settlementId is not None:
23330 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23331 
      oprot.writeI64(self.settlementId)
23332 
      oprot.writeFieldEnd()
23333 
    oprot.writeFieldStop()
23334 
    oprot.writeStructEnd()
23335 
 
23336 
  def validate(self):
23337 
    return
23338 
 
23339 
 
23340 
  def __repr__(self):
23341 
    L = ['%s=%r' % (key, value)
23342 
      for key, value in self.__dict__.iteritems()]
23343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23344 
 
23345 
  def __eq__(self, other):
23346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23347 
 
23348 
  def __ne__(self, other):
23349 
    return not (self == other)
23350 
 
23351 
class markEBSSettlementUploaded_result:
23352 
  """
23353 
  Attributes:
23354 
   - ex
23355 
  """
23356 
 
23357 
  thrift_spec = (
23358 
    None, # 0
23359 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23360 
  )
23361 
 
23362 
  def __init__(self, ex=None,):
23363 
    self.ex = ex
23364 
 
23365 
  def read(self, iprot):
23366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23368 
      return
23369 
    iprot.readStructBegin()
23370 
    while True:
23371 
      (fname, ftype, fid) = iprot.readFieldBegin()
23372 
      if ftype == TType.STOP:
23373 
        break
23374 
      if fid == 1:
23375 
        if ftype == TType.STRUCT:
23376 
          self.ex = TransactionServiceException()
23377 
          self.ex.read(iprot)
23378 
        else:
23379 
          iprot.skip(ftype)
23380 
      else:
23381 
        iprot.skip(ftype)
23382 
      iprot.readFieldEnd()
23383 
    iprot.readStructEnd()
23384 
 
23385 
  def write(self, oprot):
23386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23388 
      return
23389 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23390 
    if self.ex is not None:
23391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23392 
      self.ex.write(oprot)
23393 
      oprot.writeFieldEnd()
23394 
    oprot.writeFieldStop()
23395 
    oprot.writeStructEnd()
23396 
 
23397 
  def validate(self):
23398 
    return
23399 
 
23400 
 
23401 
  def __repr__(self):
23402 
    L = ['%s=%r' % (key, value)
23403 
      for key, value in self.__dict__.iteritems()]
23404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23405 
 
23406 
  def __eq__(self, other):
23407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23408 
 
23409 
  def __ne__(self, other):
23410 
    return not (self == other)
23411 
 
23412 
class getEBSSettlementDate_args:
23413 
  """
23414 
  Attributes:
23415 
   - settlementId
23416 
  """
23417 
 
23418 
  thrift_spec = (
23419 
    None, # 0
23420 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23421 
  )
23422 
 
23423 
  def __init__(self, settlementId=None,):
23424 
    self.settlementId = settlementId
23425 
 
23426 
  def read(self, iprot):
23427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23429 
      return
23430 
    iprot.readStructBegin()
23431 
    while True:
23432 
      (fname, ftype, fid) = iprot.readFieldBegin()
23433 
      if ftype == TType.STOP:
23434 
        break
23435 
      if fid == 1:
23436 
        if ftype == TType.I64:
23437 
          self.settlementId = iprot.readI64();
23438 
        else:
23439 
          iprot.skip(ftype)
23440 
      else:
23441 
        iprot.skip(ftype)
23442 
      iprot.readFieldEnd()
23443 
    iprot.readStructEnd()
23444 
 
23445 
  def write(self, oprot):
23446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23448 
      return
23449 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23450 
    if self.settlementId is not None:
23451 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23452 
      oprot.writeI64(self.settlementId)
23453 
      oprot.writeFieldEnd()
23454 
    oprot.writeFieldStop()
23455 
    oprot.writeStructEnd()
23456 
 
23457 
  def validate(self):
23458 
    return
23459 
 
23460 
 
23461 
  def __repr__(self):
23462 
    L = ['%s=%r' % (key, value)
23463 
      for key, value in self.__dict__.iteritems()]
23464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23465 
 
23466 
  def __eq__(self, other):
23467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23468 
 
23469 
  def __ne__(self, other):
23470 
    return not (self == other)
23471 
 
23472 
class getEBSSettlementDate_result:
23473 
  """
23474 
  Attributes:
23475 
   - success
23476 
   - ex
23477 
  """
23478 
 
23479 
  thrift_spec = (
23480 
    (0, TType.I64, 'success', None, None, ), # 0
23481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23482 
  )
23483 
 
23484 
  def __init__(self, success=None, ex=None,):
23485 
    self.success = success
23486 
    self.ex = ex
23487 
 
23488 
  def read(self, iprot):
23489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23491 
      return
23492 
    iprot.readStructBegin()
23493 
    while True:
23494 
      (fname, ftype, fid) = iprot.readFieldBegin()
23495 
      if ftype == TType.STOP:
23496 
        break
23497 
      if fid == 0:
23498 
        if ftype == TType.I64:
23499 
          self.success = iprot.readI64();
23500 
        else:
23501 
          iprot.skip(ftype)
23502 
      elif fid == 1:
23503 
        if ftype == TType.STRUCT:
23504 
          self.ex = TransactionServiceException()
23505 
          self.ex.read(iprot)
23506 
        else:
23507 
          iprot.skip(ftype)
23508 
      else:
23509 
        iprot.skip(ftype)
23510 
      iprot.readFieldEnd()
23511 
    iprot.readStructEnd()
23512 
 
23513 
  def write(self, oprot):
23514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23516 
      return
23517 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23518 
    if self.success is not None:
23519 
      oprot.writeFieldBegin('success', TType.I64, 0)
23520 
      oprot.writeI64(self.success)
23521 
      oprot.writeFieldEnd()
23522 
    if self.ex is not None:
23523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23524 
      self.ex.write(oprot)
23525 
      oprot.writeFieldEnd()
23526 
    oprot.writeFieldStop()
23527 
    oprot.writeStructEnd()
23528 
 
23529 
  def validate(self):
23530 
    return
23531 
 
23532 
 
23533 
  def __repr__(self):
23534 
    L = ['%s=%r' % (key, value)
23535 
      for key, value in self.__dict__.iteritems()]
23536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23537 
 
23538 
  def __eq__(self, other):
23539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23540 
 
23541 
  def __ne__(self, other):
23542 
    return not (self == other)
4715 varun.gupt 23543 
 
23544 
class getSettlementsByDate_args:
23545 
  """
23546 
  Attributes:
23547 
   - settlementDateFrom
23548 
   - settlementDateTo
23549 
   - isRefund
23550 
  """
23551 
 
23552 
  thrift_spec = (
23553 
    None, # 0
23554 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23555 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23556 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23557 
  )
23558 
 
23559 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23560 
    self.settlementDateFrom = settlementDateFrom
23561 
    self.settlementDateTo = settlementDateTo
23562 
    self.isRefund = isRefund
23563 
 
23564 
  def read(self, iprot):
23565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23567 
      return
23568 
    iprot.readStructBegin()
23569 
    while True:
23570 
      (fname, ftype, fid) = iprot.readFieldBegin()
23571 
      if ftype == TType.STOP:
23572 
        break
23573 
      if fid == 1:
23574 
        if ftype == TType.I64:
23575 
          self.settlementDateFrom = iprot.readI64();
23576 
        else:
23577 
          iprot.skip(ftype)
23578 
      elif fid == 2:
23579 
        if ftype == TType.I64:
23580 
          self.settlementDateTo = iprot.readI64();
23581 
        else:
23582 
          iprot.skip(ftype)
23583 
      elif fid == 3:
23584 
        if ftype == TType.BOOL:
23585 
          self.isRefund = iprot.readBool();
23586 
        else:
23587 
          iprot.skip(ftype)
23588 
      else:
23589 
        iprot.skip(ftype)
23590 
      iprot.readFieldEnd()
23591 
    iprot.readStructEnd()
23592 
 
23593 
  def write(self, oprot):
23594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23596 
      return
23597 
    oprot.writeStructBegin('getSettlementsByDate_args')
23598 
    if self.settlementDateFrom is not None:
23599 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23600 
      oprot.writeI64(self.settlementDateFrom)
23601 
      oprot.writeFieldEnd()
23602 
    if self.settlementDateTo is not None:
23603 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23604 
      oprot.writeI64(self.settlementDateTo)
23605 
      oprot.writeFieldEnd()
23606 
    if self.isRefund is not None:
23607 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23608 
      oprot.writeBool(self.isRefund)
23609 
      oprot.writeFieldEnd()
23610 
    oprot.writeFieldStop()
23611 
    oprot.writeStructEnd()
23612 
 
23613 
  def validate(self):
23614 
    return
23615 
 
23616 
 
23617 
  def __repr__(self):
23618 
    L = ['%s=%r' % (key, value)
23619 
      for key, value in self.__dict__.iteritems()]
23620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23621 
 
23622 
  def __eq__(self, other):
23623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23624 
 
23625 
  def __ne__(self, other):
23626 
    return not (self == other)
23627 
 
23628 
class getSettlementsByDate_result:
23629 
  """
23630 
  Attributes:
23631 
   - success
23632 
   - ex
23633 
  """
23634 
 
23635 
  thrift_spec = (
23636 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23637 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23638 
  )
23639 
 
23640 
  def __init__(self, success=None, ex=None,):
23641 
    self.success = success
23642 
    self.ex = ex
23643 
 
23644 
  def read(self, iprot):
23645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23647 
      return
23648 
    iprot.readStructBegin()
23649 
    while True:
23650 
      (fname, ftype, fid) = iprot.readFieldBegin()
23651 
      if ftype == TType.STOP:
23652 
        break
23653 
      if fid == 0:
23654 
        if ftype == TType.LIST:
23655 
          self.success = []
6031 rajveer 23656 
          (_etype523, _size520) = iprot.readListBegin()
23657 
          for _i524 in xrange(_size520):
23658 
            _elem525 = PaymentSettlement()
23659 
            _elem525.read(iprot)
23660 
            self.success.append(_elem525)
4715 varun.gupt 23661 
          iprot.readListEnd()
23662 
        else:
23663 
          iprot.skip(ftype)
23664 
      elif fid == 1:
23665 
        if ftype == TType.STRUCT:
23666 
          self.ex = TransactionServiceException()
23667 
          self.ex.read(iprot)
23668 
        else:
23669 
          iprot.skip(ftype)
23670 
      else:
23671 
        iprot.skip(ftype)
23672 
      iprot.readFieldEnd()
23673 
    iprot.readStructEnd()
23674 
 
23675 
  def write(self, oprot):
23676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23678 
      return
23679 
    oprot.writeStructBegin('getSettlementsByDate_result')
23680 
    if self.success is not None:
23681 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23682 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23683 
      for iter526 in self.success:
23684 
        iter526.write(oprot)
4715 varun.gupt 23685 
      oprot.writeListEnd()
23686 
      oprot.writeFieldEnd()
23687 
    if self.ex is not None:
23688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23689 
      self.ex.write(oprot)
23690 
      oprot.writeFieldEnd()
23691 
    oprot.writeFieldStop()
23692 
    oprot.writeStructEnd()
23693 
 
23694 
  def validate(self):
23695 
    return
23696 
 
23697 
 
23698 
  def __repr__(self):
23699 
    L = ['%s=%r' % (key, value)
23700 
      for key, value in self.__dict__.iteritems()]
23701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23702 
 
23703 
  def __eq__(self, other):
23704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23705 
 
23706 
  def __ne__(self, other):
23707 
    return not (self == other)
23708 
 
23709 
class getReshippedOrderIds_args:
23710 
  """
23711 
  Attributes:
23712 
   - orderIds
23713 
  """
23714 
 
23715 
  thrift_spec = (
23716 
    None, # 0
23717 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23718 
  )
23719 
 
23720 
  def __init__(self, orderIds=None,):
23721 
    self.orderIds = orderIds
23722 
 
23723 
  def read(self, iprot):
23724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23726 
      return
23727 
    iprot.readStructBegin()
23728 
    while True:
23729 
      (fname, ftype, fid) = iprot.readFieldBegin()
23730 
      if ftype == TType.STOP:
23731 
        break
23732 
      if fid == 1:
23733 
        if ftype == TType.LIST:
23734 
          self.orderIds = []
6031 rajveer 23735 
          (_etype530, _size527) = iprot.readListBegin()
23736 
          for _i531 in xrange(_size527):
23737 
            _elem532 = iprot.readI64();
23738 
            self.orderIds.append(_elem532)
4715 varun.gupt 23739 
          iprot.readListEnd()
23740 
        else:
23741 
          iprot.skip(ftype)
23742 
      else:
23743 
        iprot.skip(ftype)
23744 
      iprot.readFieldEnd()
23745 
    iprot.readStructEnd()
23746 
 
23747 
  def write(self, oprot):
23748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23750 
      return
23751 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23752 
    if self.orderIds is not None:
23753 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23754 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 23755 
      for iter533 in self.orderIds:
23756 
        oprot.writeI64(iter533)
4715 varun.gupt 23757 
      oprot.writeListEnd()
23758 
      oprot.writeFieldEnd()
23759 
    oprot.writeFieldStop()
23760 
    oprot.writeStructEnd()
23761 
 
23762 
  def validate(self):
23763 
    return
23764 
 
23765 
 
23766 
  def __repr__(self):
23767 
    L = ['%s=%r' % (key, value)
23768 
      for key, value in self.__dict__.iteritems()]
23769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23770 
 
23771 
  def __eq__(self, other):
23772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23773 
 
23774 
  def __ne__(self, other):
23775 
    return not (self == other)
23776 
 
23777 
class getReshippedOrderIds_result:
23778 
  """
23779 
  Attributes:
23780 
   - success
23781 
   - ex
23782 
  """
23783 
 
23784 
  thrift_spec = (
23785 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23787 
  )
23788 
 
23789 
  def __init__(self, success=None, ex=None,):
23790 
    self.success = success
23791 
    self.ex = ex
23792 
 
23793 
  def read(self, iprot):
23794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23796 
      return
23797 
    iprot.readStructBegin()
23798 
    while True:
23799 
      (fname, ftype, fid) = iprot.readFieldBegin()
23800 
      if ftype == TType.STOP:
23801 
        break
23802 
      if fid == 0:
23803 
        if ftype == TType.LIST:
23804 
          self.success = []
6031 rajveer 23805 
          (_etype537, _size534) = iprot.readListBegin()
23806 
          for _i538 in xrange(_size534):
23807 
            _elem539 = iprot.readI64();
23808 
            self.success.append(_elem539)
4715 varun.gupt 23809 
          iprot.readListEnd()
23810 
        else:
23811 
          iprot.skip(ftype)
23812 
      elif fid == 1:
23813 
        if ftype == TType.STRUCT:
23814 
          self.ex = TransactionServiceException()
23815 
          self.ex.read(iprot)
23816 
        else:
23817 
          iprot.skip(ftype)
23818 
      else:
23819 
        iprot.skip(ftype)
23820 
      iprot.readFieldEnd()
23821 
    iprot.readStructEnd()
23822 
 
23823 
  def write(self, oprot):
23824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23826 
      return
23827 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23828 
    if self.success is not None:
23829 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23830 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 23831 
      for iter540 in self.success:
23832 
        oprot.writeI64(iter540)
4715 varun.gupt 23833 
      oprot.writeListEnd()
23834 
      oprot.writeFieldEnd()
23835 
    if self.ex is not None:
23836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23837 
      self.ex.write(oprot)
23838 
      oprot.writeFieldEnd()
23839 
    oprot.writeFieldStop()
23840 
    oprot.writeStructEnd()
23841 
 
23842 
  def validate(self):
23843 
    return
23844 
 
23845 
 
23846 
  def __repr__(self):
23847 
    L = ['%s=%r' % (key, value)
23848 
      for key, value in self.__dict__.iteritems()]
23849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23850 
 
23851 
  def __eq__(self, other):
23852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23853 
 
23854 
  def __ne__(self, other):
23855 
    return not (self == other)
4757 mandeep.dh 23856 
 
5481 phani.kuma 23857 
class getBilledOrders_args:
4875 varun.gupt 23858 
  """
23859 
  Attributes:
23860 
   - vendorId
5481 phani.kuma 23861 
   - onlyVendorNotPaid
23862 
   - billingDateFrom
23863 
   - billingDateTo
4875 varun.gupt 23864 
  """
23865 
 
23866 
  thrift_spec = (
23867 
    None, # 0
23868 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23869 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23870 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23871 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23872 
  )
23873 
 
5481 phani.kuma 23874 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23875 
    self.vendorId = vendorId
5481 phani.kuma 23876 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23877 
    self.billingDateFrom = billingDateFrom
23878 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23879 
 
23880 
  def read(self, iprot):
23881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23883 
      return
23884 
    iprot.readStructBegin()
23885 
    while True:
23886 
      (fname, ftype, fid) = iprot.readFieldBegin()
23887 
      if ftype == TType.STOP:
23888 
        break
23889 
      if fid == 1:
23890 
        if ftype == TType.I64:
23891 
          self.vendorId = iprot.readI64();
23892 
        else:
23893 
          iprot.skip(ftype)
5481 phani.kuma 23894 
      elif fid == 2:
23895 
        if ftype == TType.BOOL:
23896 
          self.onlyVendorNotPaid = iprot.readBool();
23897 
        else:
23898 
          iprot.skip(ftype)
23899 
      elif fid == 3:
23900 
        if ftype == TType.I64:
23901 
          self.billingDateFrom = iprot.readI64();
23902 
        else:
23903 
          iprot.skip(ftype)
23904 
      elif fid == 4:
23905 
        if ftype == TType.I64:
23906 
          self.billingDateTo = iprot.readI64();
23907 
        else:
23908 
          iprot.skip(ftype)
4875 varun.gupt 23909 
      else:
23910 
        iprot.skip(ftype)
23911 
      iprot.readFieldEnd()
23912 
    iprot.readStructEnd()
23913 
 
23914 
  def write(self, oprot):
23915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23917 
      return
5481 phani.kuma 23918 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23919 
    if self.vendorId is not None:
23920 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23921 
      oprot.writeI64(self.vendorId)
23922 
      oprot.writeFieldEnd()
5481 phani.kuma 23923 
    if self.onlyVendorNotPaid is not None:
23924 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23925 
      oprot.writeBool(self.onlyVendorNotPaid)
23926 
      oprot.writeFieldEnd()
23927 
    if self.billingDateFrom is not None:
23928 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23929 
      oprot.writeI64(self.billingDateFrom)
23930 
      oprot.writeFieldEnd()
23931 
    if self.billingDateTo is not None:
23932 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23933 
      oprot.writeI64(self.billingDateTo)
23934 
      oprot.writeFieldEnd()
4875 varun.gupt 23935 
    oprot.writeFieldStop()
23936 
    oprot.writeStructEnd()
23937 
 
23938 
  def validate(self):
23939 
    return
23940 
 
23941 
 
23942 
  def __repr__(self):
23943 
    L = ['%s=%r' % (key, value)
23944 
      for key, value in self.__dict__.iteritems()]
23945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23946 
 
23947 
  def __eq__(self, other):
23948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23949 
 
23950 
  def __ne__(self, other):
23951 
    return not (self == other)
23952 
 
5481 phani.kuma 23953 
class getBilledOrders_result:
4875 varun.gupt 23954 
  """
23955 
  Attributes:
23956 
   - success
23957 
   - ex
23958 
  """
23959 
 
23960 
  thrift_spec = (
23961 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23962 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23963 
  )
23964 
 
23965 
  def __init__(self, success=None, ex=None,):
23966 
    self.success = success
23967 
    self.ex = ex
23968 
 
23969 
  def read(self, iprot):
23970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23972 
      return
23973 
    iprot.readStructBegin()
23974 
    while True:
23975 
      (fname, ftype, fid) = iprot.readFieldBegin()
23976 
      if ftype == TType.STOP:
23977 
        break
23978 
      if fid == 0:
23979 
        if ftype == TType.LIST:
23980 
          self.success = []
6031 rajveer 23981 
          (_etype544, _size541) = iprot.readListBegin()
23982 
          for _i545 in xrange(_size541):
23983 
            _elem546 = Order()
23984 
            _elem546.read(iprot)
23985 
            self.success.append(_elem546)
4875 varun.gupt 23986 
          iprot.readListEnd()
23987 
        else:
23988 
          iprot.skip(ftype)
23989 
      elif fid == 1:
23990 
        if ftype == TType.STRUCT:
23991 
          self.ex = TransactionServiceException()
23992 
          self.ex.read(iprot)
23993 
        else:
23994 
          iprot.skip(ftype)
23995 
      else:
23996 
        iprot.skip(ftype)
23997 
      iprot.readFieldEnd()
23998 
    iprot.readStructEnd()
23999 
 
24000 
  def write(self, oprot):
24001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24003 
      return
5481 phani.kuma 24004 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24005 
    if self.success is not None:
24006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24008 
      for iter547 in self.success:
24009 
        iter547.write(oprot)
4875 varun.gupt 24010 
      oprot.writeListEnd()
24011 
      oprot.writeFieldEnd()
24012 
    if self.ex is not None:
24013 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24014 
      self.ex.write(oprot)
24015 
      oprot.writeFieldEnd()
24016 
    oprot.writeFieldStop()
24017 
    oprot.writeStructEnd()
24018 
 
24019 
  def validate(self):
24020 
    return
24021 
 
24022 
 
24023 
  def __repr__(self):
24024 
    L = ['%s=%r' % (key, value)
24025 
      for key, value in self.__dict__.iteritems()]
24026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24027 
 
24028 
  def __eq__(self, other):
24029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24030 
 
24031 
  def __ne__(self, other):
24032 
    return not (self == other)
5031 varun.gupt 24033 
 
24034 
class getStatusDistributionOfOrders_args:
24035 
  """
24036 
  Attributes:
24037 
   - startDate
24038 
   - endDate
24039 
  """
24040 
 
24041 
  thrift_spec = (
24042 
    None, # 0
24043 
    (1, TType.I64, 'startDate', None, None, ), # 1
24044 
    (2, TType.I64, 'endDate', None, None, ), # 2
24045 
  )
24046 
 
24047 
  def __init__(self, startDate=None, endDate=None,):
24048 
    self.startDate = startDate
24049 
    self.endDate = endDate
24050 
 
24051 
  def read(self, iprot):
24052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24054 
      return
24055 
    iprot.readStructBegin()
24056 
    while True:
24057 
      (fname, ftype, fid) = iprot.readFieldBegin()
24058 
      if ftype == TType.STOP:
24059 
        break
24060 
      if fid == 1:
24061 
        if ftype == TType.I64:
24062 
          self.startDate = iprot.readI64();
24063 
        else:
24064 
          iprot.skip(ftype)
24065 
      elif fid == 2:
24066 
        if ftype == TType.I64:
24067 
          self.endDate = iprot.readI64();
24068 
        else:
24069 
          iprot.skip(ftype)
24070 
      else:
24071 
        iprot.skip(ftype)
24072 
      iprot.readFieldEnd()
24073 
    iprot.readStructEnd()
24074 
 
24075 
  def write(self, oprot):
24076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24078 
      return
24079 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24080 
    if self.startDate is not None:
24081 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24082 
      oprot.writeI64(self.startDate)
24083 
      oprot.writeFieldEnd()
24084 
    if self.endDate is not None:
24085 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24086 
      oprot.writeI64(self.endDate)
24087 
      oprot.writeFieldEnd()
24088 
    oprot.writeFieldStop()
24089 
    oprot.writeStructEnd()
24090 
 
24091 
  def validate(self):
24092 
    return
24093 
 
24094 
 
24095 
  def __repr__(self):
24096 
    L = ['%s=%r' % (key, value)
24097 
      for key, value in self.__dict__.iteritems()]
24098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24099 
 
24100 
  def __eq__(self, other):
24101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24102 
 
24103 
  def __ne__(self, other):
24104 
    return not (self == other)
24105 
 
24106 
class getStatusDistributionOfOrders_result:
24107 
  """
24108 
  Attributes:
24109 
   - success
24110 
   - ex
24111 
  """
24112 
 
24113 
  thrift_spec = (
24114 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24116 
  )
24117 
 
24118 
  def __init__(self, success=None, ex=None,):
24119 
    self.success = success
24120 
    self.ex = ex
24121 
 
24122 
  def read(self, iprot):
24123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24125 
      return
24126 
    iprot.readStructBegin()
24127 
    while True:
24128 
      (fname, ftype, fid) = iprot.readFieldBegin()
24129 
      if ftype == TType.STOP:
24130 
        break
24131 
      if fid == 0:
24132 
        if ftype == TType.MAP:
24133 
          self.success = {}
6031 rajveer 24134 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
24135 
          for _i552 in xrange(_size548):
24136 
            _key553 = iprot.readI64();
24137 
            _val554 = iprot.readI64();
24138 
            self.success[_key553] = _val554
5031 varun.gupt 24139 
          iprot.readMapEnd()
24140 
        else:
24141 
          iprot.skip(ftype)
24142 
      elif fid == 1:
24143 
        if ftype == TType.STRUCT:
24144 
          self.ex = TransactionServiceException()
24145 
          self.ex.read(iprot)
24146 
        else:
24147 
          iprot.skip(ftype)
24148 
      else:
24149 
        iprot.skip(ftype)
24150 
      iprot.readFieldEnd()
24151 
    iprot.readStructEnd()
24152 
 
24153 
  def write(self, oprot):
24154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24156 
      return
24157 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24158 
    if self.success is not None:
24159 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24160 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 24161 
      for kiter555,viter556 in self.success.items():
24162 
        oprot.writeI64(kiter555)
24163 
        oprot.writeI64(viter556)
5031 varun.gupt 24164 
      oprot.writeMapEnd()
24165 
      oprot.writeFieldEnd()
24166 
    if self.ex is not None:
24167 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24168 
      self.ex.write(oprot)
24169 
      oprot.writeFieldEnd()
24170 
    oprot.writeFieldStop()
24171 
    oprot.writeStructEnd()
24172 
 
24173 
  def validate(self):
24174 
    return
24175 
 
24176 
 
24177 
  def __repr__(self):
24178 
    L = ['%s=%r' % (key, value)
24179 
      for key, value in self.__dict__.iteritems()]
24180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24181 
 
24182 
  def __eq__(self, other):
24183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24184 
 
24185 
  def __ne__(self, other):
24186 
    return not (self == other)
5067 varun.gupt 24187 
 
24188 
class getOrderIdsForStatus_args:
24189 
  """
24190 
  Attributes:
24191 
   - status
24192 
   - startDatetime
24193 
   - endDatetime
24194 
  """
24195 
 
24196 
  thrift_spec = (
24197 
    None, # 0
24198 
    (1, TType.I64, 'status', None, None, ), # 1
24199 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24200 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24201 
  )
24202 
 
24203 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24204 
    self.status = status
24205 
    self.startDatetime = startDatetime
24206 
    self.endDatetime = endDatetime
24207 
 
24208 
  def read(self, iprot):
24209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24211 
      return
24212 
    iprot.readStructBegin()
24213 
    while True:
24214 
      (fname, ftype, fid) = iprot.readFieldBegin()
24215 
      if ftype == TType.STOP:
24216 
        break
24217 
      if fid == 1:
24218 
        if ftype == TType.I64:
24219 
          self.status = iprot.readI64();
24220 
        else:
24221 
          iprot.skip(ftype)
24222 
      elif fid == 2:
24223 
        if ftype == TType.I64:
24224 
          self.startDatetime = iprot.readI64();
24225 
        else:
24226 
          iprot.skip(ftype)
24227 
      elif fid == 3:
24228 
        if ftype == TType.I64:
24229 
          self.endDatetime = iprot.readI64();
24230 
        else:
24231 
          iprot.skip(ftype)
24232 
      else:
24233 
        iprot.skip(ftype)
24234 
      iprot.readFieldEnd()
24235 
    iprot.readStructEnd()
24236 
 
24237 
  def write(self, oprot):
24238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24240 
      return
24241 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24242 
    if self.status is not None:
24243 
      oprot.writeFieldBegin('status', TType.I64, 1)
24244 
      oprot.writeI64(self.status)
24245 
      oprot.writeFieldEnd()
24246 
    if self.startDatetime is not None:
24247 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24248 
      oprot.writeI64(self.startDatetime)
24249 
      oprot.writeFieldEnd()
24250 
    if self.endDatetime is not None:
24251 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24252 
      oprot.writeI64(self.endDatetime)
24253 
      oprot.writeFieldEnd()
24254 
    oprot.writeFieldStop()
24255 
    oprot.writeStructEnd()
24256 
 
24257 
  def validate(self):
24258 
    return
24259 
 
24260 
 
24261 
  def __repr__(self):
24262 
    L = ['%s=%r' % (key, value)
24263 
      for key, value in self.__dict__.iteritems()]
24264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24265 
 
24266 
  def __eq__(self, other):
24267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24268 
 
24269 
  def __ne__(self, other):
24270 
    return not (self == other)
24271 
 
24272 
class getOrderIdsForStatus_result:
24273 
  """
24274 
  Attributes:
24275 
   - success
24276 
   - ex
24277 
  """
24278 
 
24279 
  thrift_spec = (
24280 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24282 
  )
24283 
 
24284 
  def __init__(self, success=None, ex=None,):
24285 
    self.success = success
24286 
    self.ex = ex
24287 
 
24288 
  def read(self, iprot):
24289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24291 
      return
24292 
    iprot.readStructBegin()
24293 
    while True:
24294 
      (fname, ftype, fid) = iprot.readFieldBegin()
24295 
      if ftype == TType.STOP:
24296 
        break
24297 
      if fid == 0:
24298 
        if ftype == TType.LIST:
24299 
          self.success = []
6031 rajveer 24300 
          (_etype560, _size557) = iprot.readListBegin()
24301 
          for _i561 in xrange(_size557):
24302 
            _elem562 = iprot.readI64();
24303 
            self.success.append(_elem562)
5067 varun.gupt 24304 
          iprot.readListEnd()
24305 
        else:
24306 
          iprot.skip(ftype)
24307 
      elif fid == 1:
24308 
        if ftype == TType.STRUCT:
24309 
          self.ex = TransactionServiceException()
24310 
          self.ex.read(iprot)
24311 
        else:
24312 
          iprot.skip(ftype)
24313 
      else:
24314 
        iprot.skip(ftype)
24315 
      iprot.readFieldEnd()
24316 
    iprot.readStructEnd()
24317 
 
24318 
  def write(self, oprot):
24319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24321 
      return
24322 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24323 
    if self.success is not None:
24324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24325 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 24326 
      for iter563 in self.success:
24327 
        oprot.writeI64(iter563)
5067 varun.gupt 24328 
      oprot.writeListEnd()
24329 
      oprot.writeFieldEnd()
24330 
    if self.ex is not None:
24331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24332 
      self.ex.write(oprot)
24333 
      oprot.writeFieldEnd()
24334 
    oprot.writeFieldStop()
24335 
    oprot.writeStructEnd()
24336 
 
24337 
  def validate(self):
24338 
    return
24339 
 
24340 
 
24341 
  def __repr__(self):
24342 
    L = ['%s=%r' % (key, value)
24343 
      for key, value in self.__dict__.iteritems()]
24344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24345 
 
24346 
  def __eq__(self, other):
24347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24348 
 
24349 
  def __ne__(self, other):
24350 
    return not (self == other)
5099 varun.gupt 24351 
 
5348 anupam.sin 24352 
class updateCODAgent_args:
24353 
  """
24354 
  Attributes:
24355 
   - agent
24356 
   - orderId
24357 
  """
24358 
 
24359 
  thrift_spec = (
24360 
    None, # 0
24361 
    (1, TType.STRING, 'agent', None, None, ), # 1
24362 
    (2, TType.I64, 'orderId', None, None, ), # 2
24363 
  )
24364 
 
24365 
  def __init__(self, agent=None, orderId=None,):
24366 
    self.agent = agent
24367 
    self.orderId = orderId
24368 
 
24369 
  def read(self, iprot):
24370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24372 
      return
24373 
    iprot.readStructBegin()
24374 
    while True:
24375 
      (fname, ftype, fid) = iprot.readFieldBegin()
24376 
      if ftype == TType.STOP:
24377 
        break
24378 
      if fid == 1:
24379 
        if ftype == TType.STRING:
24380 
          self.agent = iprot.readString();
24381 
        else:
24382 
          iprot.skip(ftype)
24383 
      elif fid == 2:
24384 
        if ftype == TType.I64:
24385 
          self.orderId = iprot.readI64();
24386 
        else:
24387 
          iprot.skip(ftype)
24388 
      else:
24389 
        iprot.skip(ftype)
24390 
      iprot.readFieldEnd()
24391 
    iprot.readStructEnd()
24392 
 
24393 
  def write(self, oprot):
24394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24396 
      return
24397 
    oprot.writeStructBegin('updateCODAgent_args')
24398 
    if self.agent is not None:
24399 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24400 
      oprot.writeString(self.agent)
24401 
      oprot.writeFieldEnd()
24402 
    if self.orderId is not None:
24403 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24404 
      oprot.writeI64(self.orderId)
24405 
      oprot.writeFieldEnd()
24406 
    oprot.writeFieldStop()
24407 
    oprot.writeStructEnd()
24408 
 
24409 
  def validate(self):
24410 
    return
24411 
 
24412 
 
24413 
  def __repr__(self):
24414 
    L = ['%s=%r' % (key, value)
24415 
      for key, value in self.__dict__.iteritems()]
24416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24417 
 
24418 
  def __eq__(self, other):
24419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24420 
 
24421 
  def __ne__(self, other):
24422 
    return not (self == other)
24423 
 
24424 
class updateCODAgent_result:
24425 
  """
24426 
  Attributes:
24427 
   - ex
24428 
  """
24429 
 
24430 
  thrift_spec = (
24431 
    None, # 0
24432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24433 
  )
24434 
 
24435 
  def __init__(self, ex=None,):
24436 
    self.ex = ex
24437 
 
24438 
  def read(self, iprot):
24439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24441 
      return
24442 
    iprot.readStructBegin()
24443 
    while True:
24444 
      (fname, ftype, fid) = iprot.readFieldBegin()
24445 
      if ftype == TType.STOP:
24446 
        break
24447 
      if fid == 1:
24448 
        if ftype == TType.STRUCT:
24449 
          self.ex = TransactionServiceException()
24450 
          self.ex.read(iprot)
24451 
        else:
24452 
          iprot.skip(ftype)
24453 
      else:
24454 
        iprot.skip(ftype)
24455 
      iprot.readFieldEnd()
24456 
    iprot.readStructEnd()
24457 
 
24458 
  def write(self, oprot):
24459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24461 
      return
24462 
    oprot.writeStructBegin('updateCODAgent_result')
24463 
    if self.ex is not None:
24464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24465 
      self.ex.write(oprot)
24466 
      oprot.writeFieldEnd()
24467 
    oprot.writeFieldStop()
24468 
    oprot.writeStructEnd()
24469 
 
24470 
  def validate(self):
24471 
    return
24472 
 
24473 
 
24474 
  def __repr__(self):
24475 
    L = ['%s=%r' % (key, value)
24476 
      for key, value in self.__dict__.iteritems()]
24477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24478 
 
24479 
  def __eq__(self, other):
24480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24481 
 
24482 
  def __ne__(self, other):
24483 
    return not (self == other)
24484 
 
5099 varun.gupt 24485 
class updateOrderAsPaidToVendor_args:
24486 
  """
24487 
  Attributes:
24488 
   - orderId
24489 
  """
24490 
 
24491 
  thrift_spec = (
24492 
    None, # 0
24493 
    (1, TType.I64, 'orderId', None, None, ), # 1
24494 
  )
24495 
 
24496 
  def __init__(self, orderId=None,):
24497 
    self.orderId = orderId
24498 
 
24499 
  def read(self, iprot):
24500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24502 
      return
24503 
    iprot.readStructBegin()
24504 
    while True:
24505 
      (fname, ftype, fid) = iprot.readFieldBegin()
24506 
      if ftype == TType.STOP:
24507 
        break
24508 
      if fid == 1:
24509 
        if ftype == TType.I64:
24510 
          self.orderId = iprot.readI64();
24511 
        else:
24512 
          iprot.skip(ftype)
24513 
      else:
24514 
        iprot.skip(ftype)
24515 
      iprot.readFieldEnd()
24516 
    iprot.readStructEnd()
24517 
 
24518 
  def write(self, oprot):
24519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24521 
      return
24522 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24523 
    if self.orderId is not None:
24524 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24525 
      oprot.writeI64(self.orderId)
24526 
      oprot.writeFieldEnd()
24527 
    oprot.writeFieldStop()
24528 
    oprot.writeStructEnd()
24529 
 
24530 
  def validate(self):
24531 
    return
24532 
 
24533 
 
24534 
  def __repr__(self):
24535 
    L = ['%s=%r' % (key, value)
24536 
      for key, value in self.__dict__.iteritems()]
24537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24538 
 
24539 
  def __eq__(self, other):
24540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24541 
 
24542 
  def __ne__(self, other):
24543 
    return not (self == other)
24544 
 
24545 
class updateOrderAsPaidToVendor_result:
24546 
  """
24547 
  Attributes:
24548 
   - ex
24549 
  """
24550 
 
24551 
  thrift_spec = (
24552 
    None, # 0
24553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24554 
  )
24555 
 
24556 
  def __init__(self, ex=None,):
24557 
    self.ex = ex
24558 
 
24559 
  def read(self, iprot):
24560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24562 
      return
24563 
    iprot.readStructBegin()
24564 
    while True:
24565 
      (fname, ftype, fid) = iprot.readFieldBegin()
24566 
      if ftype == TType.STOP:
24567 
        break
24568 
      if fid == 1:
24569 
        if ftype == TType.STRUCT:
24570 
          self.ex = TransactionServiceException()
24571 
          self.ex.read(iprot)
24572 
        else:
24573 
          iprot.skip(ftype)
24574 
      else:
24575 
        iprot.skip(ftype)
24576 
      iprot.readFieldEnd()
24577 
    iprot.readStructEnd()
24578 
 
24579 
  def write(self, oprot):
24580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24582 
      return
24583 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24584 
    if self.ex is not None:
24585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24586 
      self.ex.write(oprot)
24587 
      oprot.writeFieldEnd()
24588 
    oprot.writeFieldStop()
24589 
    oprot.writeStructEnd()
24590 
 
24591 
  def validate(self):
24592 
    return
24593 
 
24594 
 
24595 
  def __repr__(self):
24596 
    L = ['%s=%r' % (key, value)
24597 
      for key, value in self.__dict__.iteritems()]
24598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24599 
 
24600 
  def __eq__(self, other):
24601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24602 
 
24603 
  def __ne__(self, other):
24604 
    return not (self == other)
5208 varun.gupt 24605 
 
5386 phani.kuma 24606 
class updateOrderOnlyAsPaidToVendor_args:
24607 
  """
24608 
  Attributes:
24609 
   - orderId
24610 
  """
24611 
 
24612 
  thrift_spec = (
24613 
    None, # 0
24614 
    (1, TType.I64, 'orderId', None, None, ), # 1
24615 
  )
24616 
 
24617 
  def __init__(self, orderId=None,):
24618 
    self.orderId = orderId
24619 
 
24620 
  def read(self, iprot):
24621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24623 
      return
24624 
    iprot.readStructBegin()
24625 
    while True:
24626 
      (fname, ftype, fid) = iprot.readFieldBegin()
24627 
      if ftype == TType.STOP:
24628 
        break
24629 
      if fid == 1:
24630 
        if ftype == TType.I64:
24631 
          self.orderId = iprot.readI64();
24632 
        else:
24633 
          iprot.skip(ftype)
24634 
      else:
24635 
        iprot.skip(ftype)
24636 
      iprot.readFieldEnd()
24637 
    iprot.readStructEnd()
24638 
 
24639 
  def write(self, oprot):
24640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24642 
      return
24643 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24644 
    if self.orderId is not None:
24645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24646 
      oprot.writeI64(self.orderId)
24647 
      oprot.writeFieldEnd()
24648 
    oprot.writeFieldStop()
24649 
    oprot.writeStructEnd()
24650 
 
24651 
  def validate(self):
24652 
    return
24653 
 
24654 
 
24655 
  def __repr__(self):
24656 
    L = ['%s=%r' % (key, value)
24657 
      for key, value in self.__dict__.iteritems()]
24658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24659 
 
24660 
  def __eq__(self, other):
24661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24662 
 
24663 
  def __ne__(self, other):
24664 
    return not (self == other)
24665 
 
24666 
class updateOrderOnlyAsPaidToVendor_result:
24667 
  """
24668 
  Attributes:
24669 
   - ex
24670 
  """
24671 
 
24672 
  thrift_spec = (
24673 
    None, # 0
24674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24675 
  )
24676 
 
24677 
  def __init__(self, ex=None,):
24678 
    self.ex = ex
24679 
 
24680 
  def read(self, iprot):
24681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24683 
      return
24684 
    iprot.readStructBegin()
24685 
    while True:
24686 
      (fname, ftype, fid) = iprot.readFieldBegin()
24687 
      if ftype == TType.STOP:
24688 
        break
24689 
      if fid == 1:
24690 
        if ftype == TType.STRUCT:
24691 
          self.ex = TransactionServiceException()
24692 
          self.ex.read(iprot)
24693 
        else:
24694 
          iprot.skip(ftype)
24695 
      else:
24696 
        iprot.skip(ftype)
24697 
      iprot.readFieldEnd()
24698 
    iprot.readStructEnd()
24699 
 
24700 
  def write(self, oprot):
24701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24703 
      return
24704 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24705 
    if self.ex is not None:
24706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24707 
      self.ex.write(oprot)
24708 
      oprot.writeFieldEnd()
24709 
    oprot.writeFieldStop()
24710 
    oprot.writeStructEnd()
24711 
 
24712 
  def validate(self):
24713 
    return
24714 
 
24715 
 
24716 
  def __repr__(self):
24717 
    L = ['%s=%r' % (key, value)
24718 
      for key, value in self.__dict__.iteritems()]
24719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24720 
 
24721 
  def __eq__(self, other):
24722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24723 
 
24724 
  def __ne__(self, other):
24725 
    return not (self == other)
24726 
 
5208 varun.gupt 24727 
class getRefundedOrdersMarkedPaid_args:
24728 
 
24729 
  thrift_spec = (
24730 
  )
24731 
 
24732 
  def read(self, iprot):
24733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24735 
      return
24736 
    iprot.readStructBegin()
24737 
    while True:
24738 
      (fname, ftype, fid) = iprot.readFieldBegin()
24739 
      if ftype == TType.STOP:
24740 
        break
24741 
      else:
24742 
        iprot.skip(ftype)
24743 
      iprot.readFieldEnd()
24744 
    iprot.readStructEnd()
24745 
 
24746 
  def write(self, oprot):
24747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24749 
      return
24750 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24751 
    oprot.writeFieldStop()
24752 
    oprot.writeStructEnd()
24753 
 
24754 
  def validate(self):
24755 
    return
24756 
 
24757 
 
24758 
  def __repr__(self):
24759 
    L = ['%s=%r' % (key, value)
24760 
      for key, value in self.__dict__.iteritems()]
24761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24762 
 
24763 
  def __eq__(self, other):
24764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24765 
 
24766 
  def __ne__(self, other):
24767 
    return not (self == other)
24768 
 
24769 
class getRefundedOrdersMarkedPaid_result:
24770 
  """
24771 
  Attributes:
24772 
   - success
24773 
   - ex
24774 
  """
24775 
 
24776 
  thrift_spec = (
24777 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24779 
  )
24780 
 
24781 
  def __init__(self, success=None, ex=None,):
24782 
    self.success = success
24783 
    self.ex = ex
24784 
 
24785 
  def read(self, iprot):
24786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24788 
      return
24789 
    iprot.readStructBegin()
24790 
    while True:
24791 
      (fname, ftype, fid) = iprot.readFieldBegin()
24792 
      if ftype == TType.STOP:
24793 
        break
24794 
      if fid == 0:
24795 
        if ftype == TType.LIST:
24796 
          self.success = []
6031 rajveer 24797 
          (_etype567, _size564) = iprot.readListBegin()
24798 
          for _i568 in xrange(_size564):
24799 
            _elem569 = Order()
24800 
            _elem569.read(iprot)
24801 
            self.success.append(_elem569)
5208 varun.gupt 24802 
          iprot.readListEnd()
24803 
        else:
24804 
          iprot.skip(ftype)
24805 
      elif fid == 1:
24806 
        if ftype == TType.STRUCT:
24807 
          self.ex = TransactionServiceException()
24808 
          self.ex.read(iprot)
24809 
        else:
24810 
          iprot.skip(ftype)
24811 
      else:
24812 
        iprot.skip(ftype)
24813 
      iprot.readFieldEnd()
24814 
    iprot.readStructEnd()
24815 
 
24816 
  def write(self, oprot):
24817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24819 
      return
24820 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24821 
    if self.success is not None:
24822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24823 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24824 
      for iter570 in self.success:
24825 
        iter570.write(oprot)
5208 varun.gupt 24826 
      oprot.writeListEnd()
24827 
      oprot.writeFieldEnd()
24828 
    if self.ex is not None:
24829 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24830 
      self.ex.write(oprot)
24831 
      oprot.writeFieldEnd()
24832 
    oprot.writeFieldStop()
24833 
    oprot.writeStructEnd()
24834 
 
24835 
  def validate(self):
24836 
    return
24837 
 
24838 
 
24839 
  def __repr__(self):
24840 
    L = ['%s=%r' % (key, value)
24841 
      for key, value in self.__dict__.iteritems()]
24842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24843 
 
24844 
  def __eq__(self, other):
24845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24846 
 
24847 
  def __ne__(self, other):
24848 
    return not (self == other)
5447 anupam.sin 24849 
 
24850 
class getAllVerificationAgents_args:
24851 
  """
24852 
  Attributes:
24853 
   - minOrderId
24854 
   - maxOrderId
24855 
  """
24856 
 
24857 
  thrift_spec = (
24858 
    None, # 0
24859 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24860 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24861 
  )
24862 
 
24863 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24864 
    self.minOrderId = minOrderId
24865 
    self.maxOrderId = maxOrderId
24866 
 
24867 
  def read(self, iprot):
24868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24870 
      return
24871 
    iprot.readStructBegin()
24872 
    while True:
24873 
      (fname, ftype, fid) = iprot.readFieldBegin()
24874 
      if ftype == TType.STOP:
24875 
        break
24876 
      if fid == 1:
24877 
        if ftype == TType.I64:
24878 
          self.minOrderId = iprot.readI64();
24879 
        else:
24880 
          iprot.skip(ftype)
24881 
      elif fid == 2:
24882 
        if ftype == TType.I64:
24883 
          self.maxOrderId = iprot.readI64();
24884 
        else:
24885 
          iprot.skip(ftype)
24886 
      else:
24887 
        iprot.skip(ftype)
24888 
      iprot.readFieldEnd()
24889 
    iprot.readStructEnd()
24890 
 
24891 
  def write(self, oprot):
24892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24894 
      return
24895 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24896 
    if self.minOrderId is not None:
24897 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24898 
      oprot.writeI64(self.minOrderId)
24899 
      oprot.writeFieldEnd()
24900 
    if self.maxOrderId is not None:
24901 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24902 
      oprot.writeI64(self.maxOrderId)
24903 
      oprot.writeFieldEnd()
24904 
    oprot.writeFieldStop()
24905 
    oprot.writeStructEnd()
24906 
 
24907 
  def validate(self):
24908 
    return
24909 
 
24910 
 
24911 
  def __repr__(self):
24912 
    L = ['%s=%r' % (key, value)
24913 
      for key, value in self.__dict__.iteritems()]
24914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24915 
 
24916 
  def __eq__(self, other):
24917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24918 
 
24919 
  def __ne__(self, other):
24920 
    return not (self == other)
24921 
 
24922 
class getAllVerificationAgents_result:
24923 
  """
24924 
  Attributes:
24925 
   - success
24926 
  """
24927 
 
24928 
  thrift_spec = (
24929 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24930 
  )
24931 
 
24932 
  def __init__(self, success=None,):
24933 
    self.success = success
24934 
 
24935 
  def read(self, iprot):
24936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24938 
      return
24939 
    iprot.readStructBegin()
24940 
    while True:
24941 
      (fname, ftype, fid) = iprot.readFieldBegin()
24942 
      if ftype == TType.STOP:
24943 
        break
24944 
      if fid == 0:
24945 
        if ftype == TType.LIST:
24946 
          self.success = []
6031 rajveer 24947 
          (_etype574, _size571) = iprot.readListBegin()
24948 
          for _i575 in xrange(_size571):
24949 
            _elem576 = CODVerificationAgent()
24950 
            _elem576.read(iprot)
24951 
            self.success.append(_elem576)
5447 anupam.sin 24952 
          iprot.readListEnd()
24953 
        else:
24954 
          iprot.skip(ftype)
24955 
      else:
24956 
        iprot.skip(ftype)
24957 
      iprot.readFieldEnd()
24958 
    iprot.readStructEnd()
24959 
 
24960 
  def write(self, oprot):
24961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24963 
      return
24964 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24965 
    if self.success is not None:
24966 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24967 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24968 
      for iter577 in self.success:
24969 
        iter577.write(oprot)
5447 anupam.sin 24970 
      oprot.writeListEnd()
24971 
      oprot.writeFieldEnd()
24972 
    oprot.writeFieldStop()
24973 
    oprot.writeStructEnd()
24974 
 
24975 
  def validate(self):
24976 
    return
24977 
 
24978 
 
24979 
  def __repr__(self):
24980 
    L = ['%s=%r' % (key, value)
24981 
      for key, value in self.__dict__.iteritems()]
24982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24983 
 
24984 
  def __eq__(self, other):
24985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24986 
 
24987 
  def __ne__(self, other):
24988 
    return not (self == other)
5527 anupam.sin 24989 
 
24990 
class getAllAttributesForOrderId_args:
24991 
  """
24992 
  Attributes:
24993 
   - orderId
24994 
  """
24995 
 
24996 
  thrift_spec = (
24997 
    None, # 0
24998 
    (1, TType.I64, 'orderId', None, None, ), # 1
24999 
  )
25000 
 
25001 
  def __init__(self, orderId=None,):
25002 
    self.orderId = orderId
25003 
 
25004 
  def read(self, iprot):
25005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25007 
      return
25008 
    iprot.readStructBegin()
25009 
    while True:
25010 
      (fname, ftype, fid) = iprot.readFieldBegin()
25011 
      if ftype == TType.STOP:
25012 
        break
25013 
      if fid == 1:
25014 
        if ftype == TType.I64:
25015 
          self.orderId = iprot.readI64();
25016 
        else:
25017 
          iprot.skip(ftype)
25018 
      else:
25019 
        iprot.skip(ftype)
25020 
      iprot.readFieldEnd()
25021 
    iprot.readStructEnd()
25022 
 
25023 
  def write(self, oprot):
25024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25026 
      return
25027 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25028 
    if self.orderId is not None:
25029 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25030 
      oprot.writeI64(self.orderId)
25031 
      oprot.writeFieldEnd()
25032 
    oprot.writeFieldStop()
25033 
    oprot.writeStructEnd()
25034 
 
25035 
  def validate(self):
25036 
    return
25037 
 
25038 
 
25039 
  def __repr__(self):
25040 
    L = ['%s=%r' % (key, value)
25041 
      for key, value in self.__dict__.iteritems()]
25042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25043 
 
25044 
  def __eq__(self, other):
25045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25046 
 
25047 
  def __ne__(self, other):
25048 
    return not (self == other)
25049 
 
25050 
class getAllAttributesForOrderId_result:
25051 
  """
25052 
  Attributes:
25053 
   - success
25054 
  """
25055 
 
25056 
  thrift_spec = (
25057 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25058 
  )
25059 
 
25060 
  def __init__(self, success=None,):
25061 
    self.success = success
25062 
 
25063 
  def read(self, iprot):
25064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25066 
      return
25067 
    iprot.readStructBegin()
25068 
    while True:
25069 
      (fname, ftype, fid) = iprot.readFieldBegin()
25070 
      if ftype == TType.STOP:
25071 
        break
25072 
      if fid == 0:
25073 
        if ftype == TType.LIST:
25074 
          self.success = []
6031 rajveer 25075 
          (_etype581, _size578) = iprot.readListBegin()
25076 
          for _i582 in xrange(_size578):
25077 
            _elem583 = Attribute()
25078 
            _elem583.read(iprot)
25079 
            self.success.append(_elem583)
5527 anupam.sin 25080 
          iprot.readListEnd()
25081 
        else:
25082 
          iprot.skip(ftype)
25083 
      else:
25084 
        iprot.skip(ftype)
25085 
      iprot.readFieldEnd()
25086 
    iprot.readStructEnd()
25087 
 
25088 
  def write(self, oprot):
25089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25091 
      return
25092 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25093 
    if self.success is not None:
25094 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25095 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25096 
      for iter584 in self.success:
25097 
        iter584.write(oprot)
5527 anupam.sin 25098 
      oprot.writeListEnd()
25099 
      oprot.writeFieldEnd()
25100 
    oprot.writeFieldStop()
25101 
    oprot.writeStructEnd()
25102 
 
25103 
  def validate(self):
25104 
    return
25105 
 
25106 
 
25107 
  def __repr__(self):
25108 
    L = ['%s=%r' % (key, value)
25109 
      for key, value in self.__dict__.iteritems()]
25110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25111 
 
25112 
  def __eq__(self, other):
25113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25114 
 
25115 
  def __ne__(self, other):
25116 
    return not (self == other)
25117 
 
5676 rajveer 25118 
class setOrderAttributes_args:
25119 
  """
25120 
  Attributes:
25121 
   - orderId
25122 
   - attributes
25123 
  """
25124 
 
25125 
  thrift_spec = None
25126 
  def __init__(self, orderId=None, attributes=None,):
25127 
    self.orderId = orderId
25128 
    self.attributes = attributes
25129 
 
25130 
  def read(self, iprot):
25131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25133 
      return
25134 
    iprot.readStructBegin()
25135 
    while True:
25136 
      (fname, ftype, fid) = iprot.readFieldBegin()
25137 
      if ftype == TType.STOP:
25138 
        break
25139 
      if fid == 1:
25140 
        if ftype == TType.I64:
25141 
          self.orderId = iprot.readI64();
25142 
        else:
25143 
          iprot.skip(ftype)
25144 
      elif fid == -1:
25145 
        if ftype == TType.LIST:
25146 
          self.attributes = []
6031 rajveer 25147 
          (_etype588, _size585) = iprot.readListBegin()
25148 
          for _i589 in xrange(_size585):
25149 
            _elem590 = Attribute()
25150 
            _elem590.read(iprot)
25151 
            self.attributes.append(_elem590)
5676 rajveer 25152 
          iprot.readListEnd()
25153 
        else:
25154 
          iprot.skip(ftype)
25155 
      else:
25156 
        iprot.skip(ftype)
25157 
      iprot.readFieldEnd()
25158 
    iprot.readStructEnd()
25159 
 
25160 
  def write(self, oprot):
25161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25163 
      return
25164 
    oprot.writeStructBegin('setOrderAttributes_args')
25165 
    if self.attributes is not None:
25166 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25167 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6031 rajveer 25168 
      for iter591 in self.attributes:
25169 
        iter591.write(oprot)
5676 rajveer 25170 
      oprot.writeListEnd()
25171 
      oprot.writeFieldEnd()
25172 
    if self.orderId is not None:
25173 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25174 
      oprot.writeI64(self.orderId)
25175 
      oprot.writeFieldEnd()
25176 
    oprot.writeFieldStop()
25177 
    oprot.writeStructEnd()
25178 
 
25179 
  def validate(self):
25180 
    return
25181 
 
25182 
 
25183 
  def __repr__(self):
25184 
    L = ['%s=%r' % (key, value)
25185 
      for key, value in self.__dict__.iteritems()]
25186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25187 
 
25188 
  def __eq__(self, other):
25189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25190 
 
25191 
  def __ne__(self, other):
25192 
    return not (self == other)
25193 
 
25194 
class setOrderAttributes_result:
25195 
 
25196 
  thrift_spec = (
25197 
  )
25198 
 
25199 
  def read(self, iprot):
25200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25202 
      return
25203 
    iprot.readStructBegin()
25204 
    while True:
25205 
      (fname, ftype, fid) = iprot.readFieldBegin()
25206 
      if ftype == TType.STOP:
25207 
        break
25208 
      else:
25209 
        iprot.skip(ftype)
25210 
      iprot.readFieldEnd()
25211 
    iprot.readStructEnd()
25212 
 
25213 
  def write(self, oprot):
25214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25216 
      return
25217 
    oprot.writeStructBegin('setOrderAttributes_result')
25218 
    oprot.writeFieldStop()
25219 
    oprot.writeStructEnd()
25220 
 
25221 
  def validate(self):
25222 
    return
25223 
 
25224 
 
25225 
  def __repr__(self):
25226 
    L = ['%s=%r' % (key, value)
25227 
      for key, value in self.__dict__.iteritems()]
25228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25229 
 
25230 
  def __eq__(self, other):
25231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25232 
 
25233 
  def __ne__(self, other):
25234 
    return not (self == other)
25235 
 
5527 anupam.sin 25236 
class setOrderAttributeForTransaction_args:
25237 
  """
25238 
  Attributes:
25239 
   - transactionId
25240 
   - attribute
25241 
  """
25242 
 
25243 
  thrift_spec = None
25244 
  def __init__(self, transactionId=None, attribute=None,):
25245 
    self.transactionId = transactionId
25246 
    self.attribute = attribute
25247 
 
25248 
  def read(self, iprot):
25249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25251 
      return
25252 
    iprot.readStructBegin()
25253 
    while True:
25254 
      (fname, ftype, fid) = iprot.readFieldBegin()
25255 
      if ftype == TType.STOP:
25256 
        break
25257 
      if fid == 1:
25258 
        if ftype == TType.I64:
25259 
          self.transactionId = iprot.readI64();
25260 
        else:
25261 
          iprot.skip(ftype)
25262 
      elif fid == -1:
25263 
        if ftype == TType.STRUCT:
25264 
          self.attribute = Attribute()
25265 
          self.attribute.read(iprot)
25266 
        else:
25267 
          iprot.skip(ftype)
25268 
      else:
25269 
        iprot.skip(ftype)
25270 
      iprot.readFieldEnd()
25271 
    iprot.readStructEnd()
25272 
 
25273 
  def write(self, oprot):
25274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25276 
      return
25277 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25278 
    if self.attribute is not None:
25279 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25280 
      self.attribute.write(oprot)
25281 
      oprot.writeFieldEnd()
25282 
    if self.transactionId is not None:
25283 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25284 
      oprot.writeI64(self.transactionId)
25285 
      oprot.writeFieldEnd()
25286 
    oprot.writeFieldStop()
25287 
    oprot.writeStructEnd()
25288 
 
25289 
  def validate(self):
25290 
    return
25291 
 
25292 
 
25293 
  def __repr__(self):
25294 
    L = ['%s=%r' % (key, value)
25295 
      for key, value in self.__dict__.iteritems()]
25296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25297 
 
25298 
  def __eq__(self, other):
25299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25300 
 
25301 
  def __ne__(self, other):
25302 
    return not (self == other)
25303 
 
25304 
class setOrderAttributeForTransaction_result:
25305 
 
25306 
  thrift_spec = (
25307 
  )
25308 
 
25309 
  def read(self, iprot):
25310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25312 
      return
25313 
    iprot.readStructBegin()
25314 
    while True:
25315 
      (fname, ftype, fid) = iprot.readFieldBegin()
25316 
      if ftype == TType.STOP:
25317 
        break
25318 
      else:
25319 
        iprot.skip(ftype)
25320 
      iprot.readFieldEnd()
25321 
    iprot.readStructEnd()
25322 
 
25323 
  def write(self, oprot):
25324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25326 
      return
25327 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25328 
    oprot.writeFieldStop()
25329 
    oprot.writeStructEnd()
25330 
 
25331 
  def validate(self):
25332 
    return
25333 
 
25334 
 
25335 
  def __repr__(self):
25336 
    L = ['%s=%r' % (key, value)
25337 
      for key, value in self.__dict__.iteritems()]
25338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25339 
 
25340 
  def __eq__(self, other):
25341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25342 
 
25343 
  def __ne__(self, other):
25344 
    return not (self == other)
5553 rajveer 25345 
 
25346 
class getReceivePendingOrders_args:
25347 
  """
25348 
  Attributes:
25349 
   - storeId
25350 
  """
25351 
 
25352 
  thrift_spec = (
25353 
    None, # 0
25354 
    (1, TType.I64, 'storeId', None, None, ), # 1
25355 
  )
25356 
 
25357 
  def __init__(self, storeId=None,):
25358 
    self.storeId = storeId
25359 
 
25360 
  def read(self, iprot):
25361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25363 
      return
25364 
    iprot.readStructBegin()
25365 
    while True:
25366 
      (fname, ftype, fid) = iprot.readFieldBegin()
25367 
      if ftype == TType.STOP:
25368 
        break
25369 
      if fid == 1:
25370 
        if ftype == TType.I64:
25371 
          self.storeId = iprot.readI64();
25372 
        else:
25373 
          iprot.skip(ftype)
25374 
      else:
25375 
        iprot.skip(ftype)
25376 
      iprot.readFieldEnd()
25377 
    iprot.readStructEnd()
25378 
 
25379 
  def write(self, oprot):
25380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25382 
      return
25383 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25384 
    if self.storeId is not None:
25385 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25386 
      oprot.writeI64(self.storeId)
25387 
      oprot.writeFieldEnd()
25388 
    oprot.writeFieldStop()
25389 
    oprot.writeStructEnd()
25390 
 
25391 
  def validate(self):
25392 
    return
25393 
 
25394 
 
25395 
  def __repr__(self):
25396 
    L = ['%s=%r' % (key, value)
25397 
      for key, value in self.__dict__.iteritems()]
25398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25399 
 
25400 
  def __eq__(self, other):
25401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25402 
 
25403 
  def __ne__(self, other):
25404 
    return not (self == other)
25405 
 
25406 
class getReceivePendingOrders_result:
25407 
  """
25408 
  Attributes:
25409 
   - success
25410 
  """
25411 
 
25412 
  thrift_spec = (
25413 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25414 
  )
25415 
 
25416 
  def __init__(self, success=None,):
25417 
    self.success = success
25418 
 
25419 
  def read(self, iprot):
25420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25422 
      return
25423 
    iprot.readStructBegin()
25424 
    while True:
25425 
      (fname, ftype, fid) = iprot.readFieldBegin()
25426 
      if ftype == TType.STOP:
25427 
        break
25428 
      if fid == 0:
25429 
        if ftype == TType.LIST:
25430 
          self.success = []
6031 rajveer 25431 
          (_etype595, _size592) = iprot.readListBegin()
25432 
          for _i596 in xrange(_size592):
25433 
            _elem597 = Order()
25434 
            _elem597.read(iprot)
25435 
            self.success.append(_elem597)
5553 rajveer 25436 
          iprot.readListEnd()
25437 
        else:
25438 
          iprot.skip(ftype)
25439 
      else:
25440 
        iprot.skip(ftype)
25441 
      iprot.readFieldEnd()
25442 
    iprot.readStructEnd()
25443 
 
25444 
  def write(self, oprot):
25445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25447 
      return
25448 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25449 
    if self.success is not None:
25450 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25451 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25452 
      for iter598 in self.success:
25453 
        iter598.write(oprot)
5553 rajveer 25454 
      oprot.writeListEnd()
25455 
      oprot.writeFieldEnd()
25456 
    oprot.writeFieldStop()
25457 
    oprot.writeStructEnd()
25458 
 
25459 
  def validate(self):
25460 
    return
25461 
 
25462 
 
25463 
  def __repr__(self):
25464 
    L = ['%s=%r' % (key, value)
25465 
      for key, value in self.__dict__.iteritems()]
25466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25467 
 
25468 
  def __eq__(self, other):
25469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25470 
 
25471 
  def __ne__(self, other):
25472 
    return not (self == other)
25473 
 
25474 
class getReceivedAtStoreOrders_args:
25475 
  """
25476 
  Attributes:
25477 
   - storeId
25478 
  """
25479 
 
25480 
  thrift_spec = (
25481 
    None, # 0
25482 
    (1, TType.I64, 'storeId', None, None, ), # 1
25483 
  )
25484 
 
25485 
  def __init__(self, storeId=None,):
25486 
    self.storeId = storeId
25487 
 
25488 
  def read(self, iprot):
25489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25491 
      return
25492 
    iprot.readStructBegin()
25493 
    while True:
25494 
      (fname, ftype, fid) = iprot.readFieldBegin()
25495 
      if ftype == TType.STOP:
25496 
        break
25497 
      if fid == 1:
25498 
        if ftype == TType.I64:
25499 
          self.storeId = iprot.readI64();
25500 
        else:
25501 
          iprot.skip(ftype)
25502 
      else:
25503 
        iprot.skip(ftype)
25504 
      iprot.readFieldEnd()
25505 
    iprot.readStructEnd()
25506 
 
25507 
  def write(self, oprot):
25508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25510 
      return
25511 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25512 
    if self.storeId is not None:
25513 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25514 
      oprot.writeI64(self.storeId)
25515 
      oprot.writeFieldEnd()
25516 
    oprot.writeFieldStop()
25517 
    oprot.writeStructEnd()
25518 
 
25519 
  def validate(self):
25520 
    return
25521 
 
25522 
 
25523 
  def __repr__(self):
25524 
    L = ['%s=%r' % (key, value)
25525 
      for key, value in self.__dict__.iteritems()]
25526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25527 
 
25528 
  def __eq__(self, other):
25529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25530 
 
25531 
  def __ne__(self, other):
25532 
    return not (self == other)
25533 
 
25534 
class getReceivedAtStoreOrders_result:
25535 
  """
25536 
  Attributes:
25537 
   - success
25538 
  """
25539 
 
25540 
  thrift_spec = (
25541 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25542 
  )
25543 
 
25544 
  def __init__(self, success=None,):
25545 
    self.success = success
25546 
 
25547 
  def read(self, iprot):
25548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25550 
      return
25551 
    iprot.readStructBegin()
25552 
    while True:
25553 
      (fname, ftype, fid) = iprot.readFieldBegin()
25554 
      if ftype == TType.STOP:
25555 
        break
25556 
      if fid == 0:
25557 
        if ftype == TType.LIST:
25558 
          self.success = []
6031 rajveer 25559 
          (_etype602, _size599) = iprot.readListBegin()
25560 
          for _i603 in xrange(_size599):
25561 
            _elem604 = Order()
25562 
            _elem604.read(iprot)
25563 
            self.success.append(_elem604)
5553 rajveer 25564 
          iprot.readListEnd()
25565 
        else:
25566 
          iprot.skip(ftype)
25567 
      else:
25568 
        iprot.skip(ftype)
25569 
      iprot.readFieldEnd()
25570 
    iprot.readStructEnd()
25571 
 
25572 
  def write(self, oprot):
25573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25575 
      return
25576 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25577 
    if self.success is not None:
25578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25579 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25580 
      for iter605 in self.success:
25581 
        iter605.write(oprot)
5553 rajveer 25582 
      oprot.writeListEnd()
25583 
      oprot.writeFieldEnd()
25584 
    oprot.writeFieldStop()
25585 
    oprot.writeStructEnd()
25586 
 
25587 
  def validate(self):
25588 
    return
25589 
 
25590 
 
25591 
  def __repr__(self):
25592 
    L = ['%s=%r' % (key, value)
25593 
      for key, value in self.__dict__.iteritems()]
25594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25595 
 
25596 
  def __eq__(self, other):
25597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25598 
 
25599 
  def __ne__(self, other):
25600 
    return not (self == other)
5593 mandeep.dh 25601 
 
5713 rajveer 25602 
class getOrdersCollectionAtStore_args:
25603 
  """
25604 
  Attributes:
25605 
   - storeId
25606 
   - fromDate
25607 
   - toDate
25608 
   - onlyCod
25609 
  """
25610 
 
25611 
  thrift_spec = (
25612 
    None, # 0
25613 
    (1, TType.I64, 'storeId', None, None, ), # 1
25614 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25615 
    (3, TType.I64, 'toDate', None, None, ), # 3
25616 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25617 
  )
25618 
 
25619 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25620 
    self.storeId = storeId
25621 
    self.fromDate = fromDate
25622 
    self.toDate = toDate
25623 
    self.onlyCod = onlyCod
25624 
 
25625 
  def read(self, iprot):
25626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25628 
      return
25629 
    iprot.readStructBegin()
25630 
    while True:
25631 
      (fname, ftype, fid) = iprot.readFieldBegin()
25632 
      if ftype == TType.STOP:
25633 
        break
25634 
      if fid == 1:
25635 
        if ftype == TType.I64:
25636 
          self.storeId = iprot.readI64();
25637 
        else:
25638 
          iprot.skip(ftype)
25639 
      elif fid == 2:
25640 
        if ftype == TType.I64:
25641 
          self.fromDate = iprot.readI64();
25642 
        else:
25643 
          iprot.skip(ftype)
25644 
      elif fid == 3:
25645 
        if ftype == TType.I64:
25646 
          self.toDate = iprot.readI64();
25647 
        else:
25648 
          iprot.skip(ftype)
25649 
      elif fid == 4:
25650 
        if ftype == TType.BOOL:
25651 
          self.onlyCod = iprot.readBool();
25652 
        else:
25653 
          iprot.skip(ftype)
25654 
      else:
25655 
        iprot.skip(ftype)
25656 
      iprot.readFieldEnd()
25657 
    iprot.readStructEnd()
25658 
 
25659 
  def write(self, oprot):
25660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25662 
      return
25663 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25664 
    if self.storeId is not None:
25665 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25666 
      oprot.writeI64(self.storeId)
25667 
      oprot.writeFieldEnd()
25668 
    if self.fromDate is not None:
25669 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25670 
      oprot.writeI64(self.fromDate)
25671 
      oprot.writeFieldEnd()
25672 
    if self.toDate is not None:
25673 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25674 
      oprot.writeI64(self.toDate)
25675 
      oprot.writeFieldEnd()
25676 
    if self.onlyCod is not None:
25677 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25678 
      oprot.writeBool(self.onlyCod)
25679 
      oprot.writeFieldEnd()
25680 
    oprot.writeFieldStop()
25681 
    oprot.writeStructEnd()
25682 
 
25683 
  def validate(self):
25684 
    return
25685 
 
25686 
 
25687 
  def __repr__(self):
25688 
    L = ['%s=%r' % (key, value)
25689 
      for key, value in self.__dict__.iteritems()]
25690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25691 
 
25692 
  def __eq__(self, other):
25693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25694 
 
25695 
  def __ne__(self, other):
25696 
    return not (self == other)
25697 
 
25698 
class getOrdersCollectionAtStore_result:
25699 
  """
25700 
  Attributes:
25701 
   - success
25702 
  """
25703 
 
25704 
  thrift_spec = (
25705 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25706 
  )
25707 
 
25708 
  def __init__(self, success=None,):
25709 
    self.success = success
25710 
 
25711 
  def read(self, iprot):
25712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25714 
      return
25715 
    iprot.readStructBegin()
25716 
    while True:
25717 
      (fname, ftype, fid) = iprot.readFieldBegin()
25718 
      if ftype == TType.STOP:
25719 
        break
25720 
      if fid == 0:
25721 
        if ftype == TType.LIST:
25722 
          self.success = []
6031 rajveer 25723 
          (_etype609, _size606) = iprot.readListBegin()
25724 
          for _i610 in xrange(_size606):
25725 
            _elem611 = Order()
25726 
            _elem611.read(iprot)
25727 
            self.success.append(_elem611)
5713 rajveer 25728 
          iprot.readListEnd()
25729 
        else:
25730 
          iprot.skip(ftype)
25731 
      else:
25732 
        iprot.skip(ftype)
25733 
      iprot.readFieldEnd()
25734 
    iprot.readStructEnd()
25735 
 
25736 
  def write(self, oprot):
25737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25739 
      return
25740 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25741 
    if self.success is not None:
25742 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25743 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25744 
      for iter612 in self.success:
25745 
        iter612.write(oprot)
5713 rajveer 25746 
      oprot.writeListEnd()
25747 
      oprot.writeFieldEnd()
25748 
    oprot.writeFieldStop()
25749 
    oprot.writeStructEnd()
25750 
 
25751 
  def validate(self):
25752 
    return
25753 
 
25754 
 
25755 
  def __repr__(self):
25756 
    L = ['%s=%r' % (key, value)
25757 
      for key, value in self.__dict__.iteritems()]
25758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25759 
 
25760 
  def __eq__(self, other):
25761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25762 
 
25763 
  def __ne__(self, other):
25764 
    return not (self == other)
25765 
 
5833 rajveer 25766 
class getOrderAttributeValue_args:
25767 
  """
25768 
  Attributes:
25769 
   - orderId
25770 
   - attributeName
25771 
  """
25772 
 
25773 
  thrift_spec = None
25774 
  def __init__(self, orderId=None, attributeName=None,):
25775 
    self.orderId = orderId
25776 
    self.attributeName = attributeName
25777 
 
25778 
  def read(self, iprot):
25779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25781 
      return
25782 
    iprot.readStructBegin()
25783 
    while True:
25784 
      (fname, ftype, fid) = iprot.readFieldBegin()
25785 
      if ftype == TType.STOP:
25786 
        break
25787 
      if fid == 1:
25788 
        if ftype == TType.I64:
25789 
          self.orderId = iprot.readI64();
25790 
        else:
25791 
          iprot.skip(ftype)
25792 
      elif fid == -1:
25793 
        if ftype == TType.STRING:
25794 
          self.attributeName = iprot.readString();
25795 
        else:
25796 
          iprot.skip(ftype)
25797 
      else:
25798 
        iprot.skip(ftype)
25799 
      iprot.readFieldEnd()
25800 
    iprot.readStructEnd()
25801 
 
25802 
  def write(self, oprot):
25803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25805 
      return
25806 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25807 
    if self.attributeName is not None:
25808 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25809 
      oprot.writeString(self.attributeName)
25810 
      oprot.writeFieldEnd()
25811 
    if self.orderId is not None:
25812 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25813 
      oprot.writeI64(self.orderId)
25814 
      oprot.writeFieldEnd()
25815 
    oprot.writeFieldStop()
25816 
    oprot.writeStructEnd()
25817 
 
25818 
  def validate(self):
25819 
    return
25820 
 
25821 
 
25822 
  def __repr__(self):
25823 
    L = ['%s=%r' % (key, value)
25824 
      for key, value in self.__dict__.iteritems()]
25825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25826 
 
25827 
  def __eq__(self, other):
25828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25829 
 
25830 
  def __ne__(self, other):
25831 
    return not (self == other)
25832 
 
25833 
class getOrderAttributeValue_result:
25834 
  """
25835 
  Attributes:
25836 
   - success
25837 
  """
25838 
 
25839 
  thrift_spec = (
25840 
    (0, TType.STRING, 'success', None, None, ), # 0
25841 
  )
25842 
 
25843 
  def __init__(self, success=None,):
25844 
    self.success = success
25845 
 
25846 
  def read(self, iprot):
25847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25849 
      return
25850 
    iprot.readStructBegin()
25851 
    while True:
25852 
      (fname, ftype, fid) = iprot.readFieldBegin()
25853 
      if ftype == TType.STOP:
25854 
        break
25855 
      if fid == 0:
25856 
        if ftype == TType.STRING:
25857 
          self.success = iprot.readString();
25858 
        else:
25859 
          iprot.skip(ftype)
25860 
      else:
25861 
        iprot.skip(ftype)
25862 
      iprot.readFieldEnd()
25863 
    iprot.readStructEnd()
25864 
 
25865 
  def write(self, oprot):
25866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25868 
      return
25869 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25870 
    if self.success is not None:
25871 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25872 
      oprot.writeString(self.success)
25873 
      oprot.writeFieldEnd()
25874 
    oprot.writeFieldStop()
25875 
    oprot.writeStructEnd()
25876 
 
25877 
  def validate(self):
25878 
    return
25879 
 
25880 
 
25881 
  def __repr__(self):
25882 
    L = ['%s=%r' % (key, value)
25883 
      for key, value in self.__dict__.iteritems()]
25884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25885 
 
25886 
  def __eq__(self, other):
25887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25888 
 
25889 
  def __ne__(self, other):
25890 
    return not (self == other)
25891 
 
6019 rajveer 25892 
class changeJacketNumber_args:
25893 
  """
25894 
  Attributes:
25895 
   - orderId
25896 
   - jacketNumber
25897 
  """
25898 
 
25899 
  thrift_spec = (
25900 
    None, # 0
25901 
    (1, TType.I64, 'orderId', None, None, ), # 1
25902 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25903 
  )
25904 
 
25905 
  def __init__(self, orderId=None, jacketNumber=None,):
25906 
    self.orderId = orderId
25907 
    self.jacketNumber = jacketNumber
25908 
 
25909 
  def read(self, iprot):
25910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25912 
      return
25913 
    iprot.readStructBegin()
25914 
    while True:
25915 
      (fname, ftype, fid) = iprot.readFieldBegin()
25916 
      if ftype == TType.STOP:
25917 
        break
25918 
      if fid == 1:
25919 
        if ftype == TType.I64:
25920 
          self.orderId = iprot.readI64();
25921 
        else:
25922 
          iprot.skip(ftype)
25923 
      elif fid == 2:
25924 
        if ftype == TType.I64:
25925 
          self.jacketNumber = iprot.readI64();
25926 
        else:
25927 
          iprot.skip(ftype)
25928 
      else:
25929 
        iprot.skip(ftype)
25930 
      iprot.readFieldEnd()
25931 
    iprot.readStructEnd()
25932 
 
25933 
  def write(self, oprot):
25934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25936 
      return
25937 
    oprot.writeStructBegin('changeJacketNumber_args')
25938 
    if self.orderId is not None:
25939 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25940 
      oprot.writeI64(self.orderId)
25941 
      oprot.writeFieldEnd()
25942 
    if self.jacketNumber is not None:
25943 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25944 
      oprot.writeI64(self.jacketNumber)
25945 
      oprot.writeFieldEnd()
25946 
    oprot.writeFieldStop()
25947 
    oprot.writeStructEnd()
25948 
 
25949 
  def validate(self):
25950 
    return
25951 
 
25952 
 
25953 
  def __repr__(self):
25954 
    L = ['%s=%r' % (key, value)
25955 
      for key, value in self.__dict__.iteritems()]
25956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25957 
 
25958 
  def __eq__(self, other):
25959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25960 
 
25961 
  def __ne__(self, other):
25962 
    return not (self == other)
25963 
 
25964 
class changeJacketNumber_result:
25965 
  """
25966 
  Attributes:
25967 
   - success
25968 
  """
25969 
 
25970 
  thrift_spec = (
25971 
    (0, TType.BOOL, 'success', None, None, ), # 0
25972 
  )
25973 
 
25974 
  def __init__(self, success=None,):
25975 
    self.success = success
25976 
 
25977 
  def read(self, iprot):
25978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25980 
      return
25981 
    iprot.readStructBegin()
25982 
    while True:
25983 
      (fname, ftype, fid) = iprot.readFieldBegin()
25984 
      if ftype == TType.STOP:
25985 
        break
25986 
      if fid == 0:
25987 
        if ftype == TType.BOOL:
25988 
          self.success = iprot.readBool();
25989 
        else:
25990 
          iprot.skip(ftype)
25991 
      else:
25992 
        iprot.skip(ftype)
25993 
      iprot.readFieldEnd()
25994 
    iprot.readStructEnd()
25995 
 
25996 
  def write(self, oprot):
25997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25999 
      return
26000 
    oprot.writeStructBegin('changeJacketNumber_result')
26001 
    if self.success is not None:
26002 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26003 
      oprot.writeBool(self.success)
26004 
      oprot.writeFieldEnd()
26005 
    oprot.writeFieldStop()
26006 
    oprot.writeStructEnd()
26007 
 
26008 
  def validate(self):
26009 
    return
26010 
 
26011 
 
26012 
  def __repr__(self):
26013 
    L = ['%s=%r' % (key, value)
26014 
      for key, value in self.__dict__.iteritems()]
26015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26016 
 
26017 
  def __eq__(self, other):
26018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26019 
 
26020 
  def __ne__(self, other):
26021 
    return not (self == other)
26022 
 
26023 
class markOrderAsRtoInTransit_args:
26024 
  """
26025 
  Attributes:
26026 
   - orderId
26027 
  """
26028 
 
26029 
  thrift_spec = (
26030 
    None, # 0
26031 
    (1, TType.I64, 'orderId', None, None, ), # 1
26032 
  )
26033 
 
26034 
  def __init__(self, orderId=None,):
26035 
    self.orderId = orderId
26036 
 
26037 
  def read(self, iprot):
26038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26040 
      return
26041 
    iprot.readStructBegin()
26042 
    while True:
26043 
      (fname, ftype, fid) = iprot.readFieldBegin()
26044 
      if ftype == TType.STOP:
26045 
        break
26046 
      if fid == 1:
26047 
        if ftype == TType.I64:
26048 
          self.orderId = iprot.readI64();
26049 
        else:
26050 
          iprot.skip(ftype)
26051 
      else:
26052 
        iprot.skip(ftype)
26053 
      iprot.readFieldEnd()
26054 
    iprot.readStructEnd()
26055 
 
26056 
  def write(self, oprot):
26057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26059 
      return
26060 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26061 
    if self.orderId is not None:
26062 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26063 
      oprot.writeI64(self.orderId)
26064 
      oprot.writeFieldEnd()
26065 
    oprot.writeFieldStop()
26066 
    oprot.writeStructEnd()
26067 
 
26068 
  def validate(self):
26069 
    return
26070 
 
26071 
 
26072 
  def __repr__(self):
26073 
    L = ['%s=%r' % (key, value)
26074 
      for key, value in self.__dict__.iteritems()]
26075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26076 
 
26077 
  def __eq__(self, other):
26078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26079 
 
26080 
  def __ne__(self, other):
26081 
    return not (self == other)
26082 
 
26083 
class markOrderAsRtoInTransit_result:
26084 
  """
26085 
  Attributes:
26086 
   - success
26087 
  """
26088 
 
26089 
  thrift_spec = (
26090 
    (0, TType.BOOL, 'success', None, None, ), # 0
26091 
  )
26092 
 
26093 
  def __init__(self, success=None,):
26094 
    self.success = success
26095 
 
26096 
  def read(self, iprot):
26097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26099 
      return
26100 
    iprot.readStructBegin()
26101 
    while True:
26102 
      (fname, ftype, fid) = iprot.readFieldBegin()
26103 
      if ftype == TType.STOP:
26104 
        break
26105 
      if fid == 0:
26106 
        if ftype == TType.BOOL:
26107 
          self.success = iprot.readBool();
26108 
        else:
26109 
          iprot.skip(ftype)
26110 
      else:
26111 
        iprot.skip(ftype)
26112 
      iprot.readFieldEnd()
26113 
    iprot.readStructEnd()
26114 
 
26115 
  def write(self, oprot):
26116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26118 
      return
26119 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26120 
    if self.success is not None:
26121 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26122 
      oprot.writeBool(self.success)
26123 
      oprot.writeFieldEnd()
26124 
    oprot.writeFieldStop()
26125 
    oprot.writeStructEnd()
26126 
 
26127 
  def validate(self):
26128 
    return
26129 
 
26130 
 
26131 
  def __repr__(self):
26132 
    L = ['%s=%r' % (key, value)
26133 
      for key, value in self.__dict__.iteritems()]
26134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26135 
 
26136 
  def __eq__(self, other):
26137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26138 
 
26139 
  def __ne__(self, other):
26140 
    return not (self == other)
26141 
 
5593 mandeep.dh 26142 
class acceptOrderForItem_args:
26143 
  """
26144 
  Attributes:
26145 
   - itemId
26146 
   - quantity
26147 
   - fulfilmentWarehouseId
26148 
   - billingWarehouseId
26149 
  """
26150 
 
26151 
  thrift_spec = (
26152 
    None, # 0
26153 
    (1, TType.I64, 'itemId', None, None, ), # 1
26154 
    (2, TType.I64, 'quantity', None, None, ), # 2
26155 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26156 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26157 
  )
26158 
 
26159 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26160 
    self.itemId = itemId
26161 
    self.quantity = quantity
26162 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26163 
    self.billingWarehouseId = billingWarehouseId
26164 
 
26165 
  def read(self, iprot):
26166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26168 
      return
26169 
    iprot.readStructBegin()
26170 
    while True:
26171 
      (fname, ftype, fid) = iprot.readFieldBegin()
26172 
      if ftype == TType.STOP:
26173 
        break
26174 
      if fid == 1:
26175 
        if ftype == TType.I64:
26176 
          self.itemId = iprot.readI64();
26177 
        else:
26178 
          iprot.skip(ftype)
26179 
      elif fid == 2:
26180 
        if ftype == TType.I64:
26181 
          self.quantity = iprot.readI64();
26182 
        else:
26183 
          iprot.skip(ftype)
26184 
      elif fid == 3:
26185 
        if ftype == TType.I64:
26186 
          self.fulfilmentWarehouseId = iprot.readI64();
26187 
        else:
26188 
          iprot.skip(ftype)
26189 
      elif fid == 4:
26190 
        if ftype == TType.I64:
26191 
          self.billingWarehouseId = iprot.readI64();
26192 
        else:
26193 
          iprot.skip(ftype)
26194 
      else:
26195 
        iprot.skip(ftype)
26196 
      iprot.readFieldEnd()
26197 
    iprot.readStructEnd()
26198 
 
26199 
  def write(self, oprot):
26200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26202 
      return
26203 
    oprot.writeStructBegin('acceptOrderForItem_args')
26204 
    if self.itemId is not None:
26205 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26206 
      oprot.writeI64(self.itemId)
26207 
      oprot.writeFieldEnd()
26208 
    if self.quantity is not None:
26209 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26210 
      oprot.writeI64(self.quantity)
26211 
      oprot.writeFieldEnd()
26212 
    if self.fulfilmentWarehouseId is not None:
26213 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26214 
      oprot.writeI64(self.fulfilmentWarehouseId)
26215 
      oprot.writeFieldEnd()
26216 
    if self.billingWarehouseId is not None:
26217 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26218 
      oprot.writeI64(self.billingWarehouseId)
26219 
      oprot.writeFieldEnd()
26220 
    oprot.writeFieldStop()
26221 
    oprot.writeStructEnd()
26222 
 
26223 
  def validate(self):
26224 
    return
26225 
 
26226 
 
26227 
  def __repr__(self):
26228 
    L = ['%s=%r' % (key, value)
26229 
      for key, value in self.__dict__.iteritems()]
26230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26231 
 
26232 
  def __eq__(self, other):
26233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26234 
 
26235 
  def __ne__(self, other):
26236 
    return not (self == other)
26237 
 
26238 
class acceptOrderForItem_result:
26239 
 
26240 
  thrift_spec = (
26241 
  )
26242 
 
26243 
  def read(self, iprot):
26244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26246 
      return
26247 
    iprot.readStructBegin()
26248 
    while True:
26249 
      (fname, ftype, fid) = iprot.readFieldBegin()
26250 
      if ftype == TType.STOP:
26251 
        break
26252 
      else:
26253 
        iprot.skip(ftype)
26254 
      iprot.readFieldEnd()
26255 
    iprot.readStructEnd()
26256 
 
26257 
  def write(self, oprot):
26258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26260 
      return
26261 
    oprot.writeStructBegin('acceptOrderForItem_result')
26262 
    oprot.writeFieldStop()
26263 
    oprot.writeStructEnd()
26264 
 
26265 
  def validate(self):
26266 
    return
26267 
 
26268 
 
26269 
  def __repr__(self):
26270 
    L = ['%s=%r' % (key, value)
26271 
      for key, value in self.__dict__.iteritems()]
26272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26273 
 
26274 
  def __eq__(self, other):
26275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26276 
 
26277 
  def __ne__(self, other):
26278 
    return not (self == other)
6000 mandeep.dh 26279 
 
26280 
class createRechargeOrder_args:
26281 
  """
26282 
  Attributes:
26283 
   - rechargeOrder
26284 
  """
26285 
 
26286 
  thrift_spec = (
26287 
    None, # 0
26288 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26289 
  )
26290 
 
26291 
  def __init__(self, rechargeOrder=None,):
26292 
    self.rechargeOrder = rechargeOrder
26293 
 
26294 
  def read(self, iprot):
26295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26297 
      return
26298 
    iprot.readStructBegin()
26299 
    while True:
26300 
      (fname, ftype, fid) = iprot.readFieldBegin()
26301 
      if ftype == TType.STOP:
26302 
        break
26303 
      if fid == 1:
26304 
        if ftype == TType.STRUCT:
26305 
          self.rechargeOrder = RechargeOrder()
26306 
          self.rechargeOrder.read(iprot)
26307 
        else:
26308 
          iprot.skip(ftype)
26309 
      else:
26310 
        iprot.skip(ftype)
26311 
      iprot.readFieldEnd()
26312 
    iprot.readStructEnd()
26313 
 
26314 
  def write(self, oprot):
26315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26317 
      return
26318 
    oprot.writeStructBegin('createRechargeOrder_args')
26319 
    if self.rechargeOrder is not None:
26320 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26321 
      self.rechargeOrder.write(oprot)
26322 
      oprot.writeFieldEnd()
26323 
    oprot.writeFieldStop()
26324 
    oprot.writeStructEnd()
26325 
 
26326 
  def validate(self):
26327 
    return
26328 
 
26329 
 
26330 
  def __repr__(self):
26331 
    L = ['%s=%r' % (key, value)
26332 
      for key, value in self.__dict__.iteritems()]
26333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26334 
 
26335 
  def __eq__(self, other):
26336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26337 
 
26338 
  def __ne__(self, other):
26339 
    return not (self == other)
26340 
 
26341 
class createRechargeOrder_result:
26342 
  """
26343 
  Attributes:
26344 
   - success
26345 
   - ex
26346 
  """
26347 
 
26348 
  thrift_spec = (
26349 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26351 
  )
26352 
 
26353 
  def __init__(self, success=None, ex=None,):
26354 
    self.success = success
26355 
    self.ex = ex
26356 
 
26357 
  def read(self, iprot):
26358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26360 
      return
26361 
    iprot.readStructBegin()
26362 
    while True:
26363 
      (fname, ftype, fid) = iprot.readFieldBegin()
26364 
      if ftype == TType.STOP:
26365 
        break
26366 
      if fid == 0:
26367 
        if ftype == TType.STRUCT:
26368 
          self.success = RechargeOrder()
26369 
          self.success.read(iprot)
26370 
        else:
26371 
          iprot.skip(ftype)
26372 
      elif fid == 1:
26373 
        if ftype == TType.STRUCT:
26374 
          self.ex = TransactionServiceException()
26375 
          self.ex.read(iprot)
26376 
        else:
26377 
          iprot.skip(ftype)
26378 
      else:
26379 
        iprot.skip(ftype)
26380 
      iprot.readFieldEnd()
26381 
    iprot.readStructEnd()
26382 
 
26383 
  def write(self, oprot):
26384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26386 
      return
26387 
    oprot.writeStructBegin('createRechargeOrder_result')
26388 
    if self.success is not None:
26389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26390 
      self.success.write(oprot)
26391 
      oprot.writeFieldEnd()
26392 
    if self.ex is not None:
26393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26394 
      self.ex.write(oprot)
26395 
      oprot.writeFieldEnd()
26396 
    oprot.writeFieldStop()
26397 
    oprot.writeStructEnd()
26398 
 
26399 
  def validate(self):
26400 
    return
26401 
 
26402 
 
26403 
  def __repr__(self):
26404 
    L = ['%s=%r' % (key, value)
26405 
      for key, value in self.__dict__.iteritems()]
26406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26407 
 
26408 
  def __eq__(self, other):
26409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26410 
 
26411 
  def __ne__(self, other):
26412 
    return not (self == other)
26413 
 
6031 rajveer 26414 
class getRechargeOrder_args:
26415 
  """
26416 
  Attributes:
26417 
   - rechargeRrderId
26418 
  """
26419 
 
26420 
  thrift_spec = (
26421 
    None, # 0
26422 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26423 
  )
26424 
 
26425 
  def __init__(self, rechargeRrderId=None,):
26426 
    self.rechargeRrderId = rechargeRrderId
26427 
 
26428 
  def read(self, iprot):
26429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26431 
      return
26432 
    iprot.readStructBegin()
26433 
    while True:
26434 
      (fname, ftype, fid) = iprot.readFieldBegin()
26435 
      if ftype == TType.STOP:
26436 
        break
26437 
      if fid == 1:
26438 
        if ftype == TType.I64:
26439 
          self.rechargeRrderId = iprot.readI64();
26440 
        else:
26441 
          iprot.skip(ftype)
26442 
      else:
26443 
        iprot.skip(ftype)
26444 
      iprot.readFieldEnd()
26445 
    iprot.readStructEnd()
26446 
 
26447 
  def write(self, oprot):
26448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26450 
      return
26451 
    oprot.writeStructBegin('getRechargeOrder_args')
26452 
    if self.rechargeRrderId is not None:
26453 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26454 
      oprot.writeI64(self.rechargeRrderId)
26455 
      oprot.writeFieldEnd()
26456 
    oprot.writeFieldStop()
26457 
    oprot.writeStructEnd()
26458 
 
26459 
  def validate(self):
26460 
    return
26461 
 
26462 
 
26463 
  def __repr__(self):
26464 
    L = ['%s=%r' % (key, value)
26465 
      for key, value in self.__dict__.iteritems()]
26466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26467 
 
26468 
  def __eq__(self, other):
26469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26470 
 
26471 
  def __ne__(self, other):
26472 
    return not (self == other)
26473 
 
26474 
class getRechargeOrder_result:
26475 
  """
26476 
  Attributes:
26477 
   - success
26478 
   - ex
26479 
  """
26480 
 
26481 
  thrift_spec = (
26482 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26484 
  )
26485 
 
26486 
  def __init__(self, success=None, ex=None,):
26487 
    self.success = success
26488 
    self.ex = ex
26489 
 
26490 
  def read(self, iprot):
26491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26493 
      return
26494 
    iprot.readStructBegin()
26495 
    while True:
26496 
      (fname, ftype, fid) = iprot.readFieldBegin()
26497 
      if ftype == TType.STOP:
26498 
        break
26499 
      if fid == 0:
26500 
        if ftype == TType.STRUCT:
26501 
          self.success = RechargeOrder()
26502 
          self.success.read(iprot)
26503 
        else:
26504 
          iprot.skip(ftype)
26505 
      elif fid == 1:
26506 
        if ftype == TType.STRUCT:
26507 
          self.ex = TransactionServiceException()
26508 
          self.ex.read(iprot)
26509 
        else:
26510 
          iprot.skip(ftype)
26511 
      else:
26512 
        iprot.skip(ftype)
26513 
      iprot.readFieldEnd()
26514 
    iprot.readStructEnd()
26515 
 
26516 
  def write(self, oprot):
26517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26519 
      return
26520 
    oprot.writeStructBegin('getRechargeOrder_result')
26521 
    if self.success is not None:
26522 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26523 
      self.success.write(oprot)
26524 
      oprot.writeFieldEnd()
26525 
    if self.ex is not None:
26526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26527 
      self.ex.write(oprot)
26528 
      oprot.writeFieldEnd()
26529 
    oprot.writeFieldStop()
26530 
    oprot.writeStructEnd()
26531 
 
26532 
  def validate(self):
26533 
    return
26534 
 
26535 
 
26536 
  def __repr__(self):
26537 
    L = ['%s=%r' % (key, value)
26538 
      for key, value in self.__dict__.iteritems()]
26539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26540 
 
26541 
  def __eq__(self, other):
26542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26543 
 
26544 
  def __ne__(self, other):
26545 
    return not (self == other)
26546 
 
26547 
class getRechargeOrders_args:
26548 
  """
26549 
  Attributes:
26550 
   - userId
26551 
  """
26552 
 
26553 
  thrift_spec = (
26554 
    None, # 0
26555 
    (1, TType.I64, 'userId', None, None, ), # 1
26556 
  )
26557 
 
26558 
  def __init__(self, userId=None,):
26559 
    self.userId = userId
26560 
 
26561 
  def read(self, iprot):
26562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26564 
      return
26565 
    iprot.readStructBegin()
26566 
    while True:
26567 
      (fname, ftype, fid) = iprot.readFieldBegin()
26568 
      if ftype == TType.STOP:
26569 
        break
26570 
      if fid == 1:
26571 
        if ftype == TType.I64:
26572 
          self.userId = iprot.readI64();
26573 
        else:
26574 
          iprot.skip(ftype)
26575 
      else:
26576 
        iprot.skip(ftype)
26577 
      iprot.readFieldEnd()
26578 
    iprot.readStructEnd()
26579 
 
26580 
  def write(self, oprot):
26581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26583 
      return
26584 
    oprot.writeStructBegin('getRechargeOrders_args')
26585 
    if self.userId is not None:
26586 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26587 
      oprot.writeI64(self.userId)
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 getRechargeOrders_result:
26608 
  """
26609 
  Attributes:
26610 
   - success
26611 
  """
26612 
 
26613 
  thrift_spec = (
26614 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26615 
  )
26616 
 
26617 
  def __init__(self, success=None,):
26618 
    self.success = success
26619 
 
26620 
  def read(self, iprot):
26621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26623 
      return
26624 
    iprot.readStructBegin()
26625 
    while True:
26626 
      (fname, ftype, fid) = iprot.readFieldBegin()
26627 
      if ftype == TType.STOP:
26628 
        break
26629 
      if fid == 0:
26630 
        if ftype == TType.LIST:
26631 
          self.success = []
26632 
          (_etype616, _size613) = iprot.readListBegin()
26633 
          for _i617 in xrange(_size613):
26634 
            _elem618 = RechargeOrder()
26635 
            _elem618.read(iprot)
26636 
            self.success.append(_elem618)
26637 
          iprot.readListEnd()
26638 
        else:
26639 
          iprot.skip(ftype)
26640 
      else:
26641 
        iprot.skip(ftype)
26642 
      iprot.readFieldEnd()
26643 
    iprot.readStructEnd()
26644 
 
26645 
  def write(self, oprot):
26646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26648 
      return
26649 
    oprot.writeStructBegin('getRechargeOrders_result')
26650 
    if self.success is not None:
26651 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26652 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26653 
      for iter619 in self.success:
26654 
        iter619.write(oprot)
26655 
      oprot.writeListEnd()
26656 
      oprot.writeFieldEnd()
26657 
    oprot.writeFieldStop()
26658 
    oprot.writeStructEnd()
26659 
 
26660 
  def validate(self):
26661 
    return
26662 
 
26663 
 
26664 
  def __repr__(self):
26665 
    L = ['%s=%r' % (key, value)
26666 
      for key, value in self.__dict__.iteritems()]
26667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26668 
 
26669 
  def __eq__(self, other):
26670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26671 
 
26672 
  def __ne__(self, other):
26673 
    return not (self == other)
26674 
 
6000 mandeep.dh 26675 
class updateRechargeOrderStatus_args:
26676 
  """
26677 
  Attributes:
26678 
   - rechargeOrderId
26679 
   - rechargeOrderStatus
26680 
  """
26681 
 
26682 
  thrift_spec = (
26683 
    None, # 0
26684 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26685 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26686 
  )
26687 
 
26688 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26689 
    self.rechargeOrderId = rechargeOrderId
26690 
    self.rechargeOrderStatus = rechargeOrderStatus
26691 
 
26692 
  def read(self, iprot):
26693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26695 
      return
26696 
    iprot.readStructBegin()
26697 
    while True:
26698 
      (fname, ftype, fid) = iprot.readFieldBegin()
26699 
      if ftype == TType.STOP:
26700 
        break
26701 
      if fid == 1:
26702 
        if ftype == TType.I64:
26703 
          self.rechargeOrderId = iprot.readI64();
26704 
        else:
26705 
          iprot.skip(ftype)
26706 
      elif fid == 2:
26707 
        if ftype == TType.I32:
26708 
          self.rechargeOrderStatus = iprot.readI32();
26709 
        else:
26710 
          iprot.skip(ftype)
26711 
      else:
26712 
        iprot.skip(ftype)
26713 
      iprot.readFieldEnd()
26714 
    iprot.readStructEnd()
26715 
 
26716 
  def write(self, oprot):
26717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26719 
      return
26720 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26721 
    if self.rechargeOrderId is not None:
26722 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26723 
      oprot.writeI64(self.rechargeOrderId)
26724 
      oprot.writeFieldEnd()
26725 
    if self.rechargeOrderStatus is not None:
26726 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26727 
      oprot.writeI32(self.rechargeOrderStatus)
26728 
      oprot.writeFieldEnd()
26729 
    oprot.writeFieldStop()
26730 
    oprot.writeStructEnd()
26731 
 
26732 
  def validate(self):
26733 
    return
26734 
 
26735 
 
26736 
  def __repr__(self):
26737 
    L = ['%s=%r' % (key, value)
26738 
      for key, value in self.__dict__.iteritems()]
26739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26740 
 
26741 
  def __eq__(self, other):
26742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26743 
 
26744 
  def __ne__(self, other):
26745 
    return not (self == other)
26746 
 
26747 
class updateRechargeOrderStatus_result:
26748 
  """
26749 
  Attributes:
6031 rajveer 26750 
   - success
6000 mandeep.dh 26751 
   - ex
26752 
  """
26753 
 
26754 
  thrift_spec = (
6031 rajveer 26755 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26756 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26757 
  )
26758 
 
6031 rajveer 26759 
  def __init__(self, success=None, ex=None,):
26760 
    self.success = success
6000 mandeep.dh 26761 
    self.ex = ex
26762 
 
26763 
  def read(self, iprot):
26764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26766 
      return
26767 
    iprot.readStructBegin()
26768 
    while True:
26769 
      (fname, ftype, fid) = iprot.readFieldBegin()
26770 
      if ftype == TType.STOP:
26771 
        break
6031 rajveer 26772 
      if fid == 0:
26773 
        if ftype == TType.BOOL:
26774 
          self.success = iprot.readBool();
26775 
        else:
26776 
          iprot.skip(ftype)
26777 
      elif fid == 1:
6000 mandeep.dh 26778 
        if ftype == TType.STRUCT:
26779 
          self.ex = TransactionServiceException()
26780 
          self.ex.read(iprot)
26781 
        else:
26782 
          iprot.skip(ftype)
26783 
      else:
26784 
        iprot.skip(ftype)
26785 
      iprot.readFieldEnd()
26786 
    iprot.readStructEnd()
26787 
 
26788 
  def write(self, oprot):
26789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26791 
      return
26792 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26793 
    if self.success is not None:
26794 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26795 
      oprot.writeBool(self.success)
26796 
      oprot.writeFieldEnd()
6000 mandeep.dh 26797 
    if self.ex is not None:
26798 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26799 
      self.ex.write(oprot)
26800 
      oprot.writeFieldEnd()
26801 
    oprot.writeFieldStop()
26802 
    oprot.writeStructEnd()
26803 
 
26804 
  def validate(self):
26805 
    return
26806 
 
26807 
 
26808 
  def __repr__(self):
26809 
    L = ['%s=%r' % (key, value)
26810 
      for key, value in self.__dict__.iteritems()]
26811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26812 
 
26813 
  def __eq__(self, other):
26814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26815 
 
26816 
  def __ne__(self, other):
26817 
    return not (self == other)
26818 
 
26819 
class activateRechargeTxn_args:
26820 
  """
26821 
  Attributes:
6031 rajveer 26822 
   - rechargeOrderId
6000 mandeep.dh 26823 
  """
26824 
 
26825 
  thrift_spec = (
26826 
    None, # 0
6031 rajveer 26827 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26828 
  )
26829 
 
6031 rajveer 26830 
  def __init__(self, rechargeOrderId=None,):
26831 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26832 
 
26833 
  def read(self, iprot):
26834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26836 
      return
26837 
    iprot.readStructBegin()
26838 
    while True:
26839 
      (fname, ftype, fid) = iprot.readFieldBegin()
26840 
      if ftype == TType.STOP:
26841 
        break
26842 
      if fid == 1:
6031 rajveer 26843 
        if ftype == TType.I64:
26844 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26845 
        else:
26846 
          iprot.skip(ftype)
26847 
      else:
26848 
        iprot.skip(ftype)
26849 
      iprot.readFieldEnd()
26850 
    iprot.readStructEnd()
26851 
 
26852 
  def write(self, oprot):
26853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26855 
      return
26856 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26857 
    if self.rechargeOrderId is not None:
26858 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26859 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26860 
      oprot.writeFieldEnd()
26861 
    oprot.writeFieldStop()
26862 
    oprot.writeStructEnd()
26863 
 
26864 
  def validate(self):
26865 
    return
26866 
 
26867 
 
26868 
  def __repr__(self):
26869 
    L = ['%s=%r' % (key, value)
26870 
      for key, value in self.__dict__.iteritems()]
26871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26872 
 
26873 
  def __eq__(self, other):
26874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26875 
 
26876 
  def __ne__(self, other):
26877 
    return not (self == other)
26878 
 
26879 
class activateRechargeTxn_result:
26880 
  """
26881 
  Attributes:
26882 
   - success
26883 
   - ex
26884 
  """
26885 
 
26886 
  thrift_spec = (
6031 rajveer 26887 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26889 
  )
26890 
 
26891 
  def __init__(self, success=None, ex=None,):
26892 
    self.success = success
26893 
    self.ex = ex
26894 
 
26895 
  def read(self, iprot):
26896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26898 
      return
26899 
    iprot.readStructBegin()
26900 
    while True:
26901 
      (fname, ftype, fid) = iprot.readFieldBegin()
26902 
      if ftype == TType.STOP:
26903 
        break
26904 
      if fid == 0:
6031 rajveer 26905 
        if ftype == TType.BOOL:
26906 
          self.success = iprot.readBool();
6000 mandeep.dh 26907 
        else:
26908 
          iprot.skip(ftype)
26909 
      elif fid == 1:
26910 
        if ftype == TType.STRUCT:
26911 
          self.ex = TransactionServiceException()
26912 
          self.ex.read(iprot)
26913 
        else:
26914 
          iprot.skip(ftype)
26915 
      else:
26916 
        iprot.skip(ftype)
26917 
      iprot.readFieldEnd()
26918 
    iprot.readStructEnd()
26919 
 
26920 
  def write(self, oprot):
26921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26923 
      return
26924 
    oprot.writeStructBegin('activateRechargeTxn_result')
26925 
    if self.success is not None:
6031 rajveer 26926 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26927 
      oprot.writeBool(self.success)
6000 mandeep.dh 26928 
      oprot.writeFieldEnd()
26929 
    if self.ex is not None:
26930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26931 
      self.ex.write(oprot)
26932 
      oprot.writeFieldEnd()
26933 
    oprot.writeFieldStop()
26934 
    oprot.writeStructEnd()
26935 
 
26936 
  def validate(self):
26937 
    return
26938 
 
26939 
 
26940 
  def __repr__(self):
26941 
    L = ['%s=%r' % (key, value)
26942 
      for key, value in self.__dict__.iteritems()]
26943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26944 
 
26945 
  def __eq__(self, other):
26946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26947 
 
26948 
  def __ne__(self, other):
26949 
    return not (self == other)
26950 
 
6031 rajveer 26951 
class getUserWallet_args:
6000 mandeep.dh 26952 
  """
26953 
  Attributes:
6031 rajveer 26954 
   - userId
6000 mandeep.dh 26955 
  """
26956 
 
26957 
  thrift_spec = (
26958 
    None, # 0
6031 rajveer 26959 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26960 
  )
26961 
 
6031 rajveer 26962 
  def __init__(self, userId=None,):
26963 
    self.userId = userId
6000 mandeep.dh 26964 
 
26965 
  def read(self, iprot):
26966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26968 
      return
26969 
    iprot.readStructBegin()
26970 
    while True:
26971 
      (fname, ftype, fid) = iprot.readFieldBegin()
26972 
      if ftype == TType.STOP:
26973 
        break
26974 
      if fid == 1:
26975 
        if ftype == TType.I64:
6031 rajveer 26976 
          self.userId = iprot.readI64();
6000 mandeep.dh 26977 
        else:
26978 
          iprot.skip(ftype)
26979 
      else:
26980 
        iprot.skip(ftype)
26981 
      iprot.readFieldEnd()
26982 
    iprot.readStructEnd()
26983 
 
26984 
  def write(self, oprot):
26985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26987 
      return
6031 rajveer 26988 
    oprot.writeStructBegin('getUserWallet_args')
26989 
    if self.userId is not None:
26990 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26991 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26992 
      oprot.writeFieldEnd()
26993 
    oprot.writeFieldStop()
26994 
    oprot.writeStructEnd()
26995 
 
26996 
  def validate(self):
26997 
    return
26998 
 
26999 
 
27000 
  def __repr__(self):
27001 
    L = ['%s=%r' % (key, value)
27002 
      for key, value in self.__dict__.iteritems()]
27003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27004 
 
27005 
  def __eq__(self, other):
27006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27007 
 
27008 
  def __ne__(self, other):
27009 
    return not (self == other)
27010 
 
6031 rajveer 27011 
class getUserWallet_result:
6000 mandeep.dh 27012 
  """
27013 
  Attributes:
27014 
   - success
27015 
  """
27016 
 
27017 
  thrift_spec = (
6031 rajveer 27018 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27019 
  )
27020 
 
27021 
  def __init__(self, success=None,):
27022 
    self.success = success
27023 
 
27024 
  def read(self, iprot):
27025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27027 
      return
27028 
    iprot.readStructBegin()
27029 
    while True:
27030 
      (fname, ftype, fid) = iprot.readFieldBegin()
27031 
      if ftype == TType.STOP:
27032 
        break
27033 
      if fid == 0:
6031 rajveer 27034 
        if ftype == TType.STRUCT:
27035 
          self.success = UserWallet()
27036 
          self.success.read(iprot)
6000 mandeep.dh 27037 
        else:
27038 
          iprot.skip(ftype)
27039 
      else:
27040 
        iprot.skip(ftype)
27041 
      iprot.readFieldEnd()
27042 
    iprot.readStructEnd()
27043 
 
27044 
  def write(self, oprot):
27045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27047 
      return
6031 rajveer 27048 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27049 
    if self.success is not None:
6031 rajveer 27050 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27051 
      self.success.write(oprot)
6000 mandeep.dh 27052 
      oprot.writeFieldEnd()
27053 
    oprot.writeFieldStop()
27054 
    oprot.writeStructEnd()
27055 
 
27056 
  def validate(self):
27057 
    return
27058 
 
27059 
 
27060 
  def __repr__(self):
27061 
    L = ['%s=%r' % (key, value)
27062 
      for key, value in self.__dict__.iteritems()]
27063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27064 
 
27065 
  def __eq__(self, other):
27066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27067 
 
27068 
  def __ne__(self, other):
27069 
    return not (self == other)
27070 
 
6031 rajveer 27071 
class getUserWalletHistory_args:
6000 mandeep.dh 27072 
  """
27073 
  Attributes:
6031 rajveer 27074 
   - userId
6000 mandeep.dh 27075 
  """
27076 
 
27077 
  thrift_spec = (
27078 
    None, # 0
6031 rajveer 27079 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27080 
  )
27081 
 
6031 rajveer 27082 
  def __init__(self, userId=None,):
27083 
    self.userId = userId
6000 mandeep.dh 27084 
 
27085 
  def read(self, iprot):
27086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27088 
      return
27089 
    iprot.readStructBegin()
27090 
    while True:
27091 
      (fname, ftype, fid) = iprot.readFieldBegin()
27092 
      if ftype == TType.STOP:
27093 
        break
27094 
      if fid == 1:
27095 
        if ftype == TType.I64:
6031 rajveer 27096 
          self.userId = iprot.readI64();
6000 mandeep.dh 27097 
        else:
27098 
          iprot.skip(ftype)
27099 
      else:
27100 
        iprot.skip(ftype)
27101 
      iprot.readFieldEnd()
27102 
    iprot.readStructEnd()
27103 
 
27104 
  def write(self, oprot):
27105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27107 
      return
6031 rajveer 27108 
    oprot.writeStructBegin('getUserWalletHistory_args')
27109 
    if self.userId is not None:
27110 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27111 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27112 
      oprot.writeFieldEnd()
27113 
    oprot.writeFieldStop()
27114 
    oprot.writeStructEnd()
27115 
 
27116 
  def validate(self):
27117 
    return
27118 
 
27119 
 
27120 
  def __repr__(self):
27121 
    L = ['%s=%r' % (key, value)
27122 
      for key, value in self.__dict__.iteritems()]
27123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27124 
 
27125 
  def __eq__(self, other):
27126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27127 
 
27128 
  def __ne__(self, other):
27129 
    return not (self == other)
27130 
 
6031 rajveer 27131 
class getUserWalletHistory_result:
6000 mandeep.dh 27132 
  """
27133 
  Attributes:
27134 
   - success
27135 
  """
27136 
 
27137 
  thrift_spec = (
6031 rajveer 27138 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27139 
  )
27140 
 
27141 
  def __init__(self, success=None,):
27142 
    self.success = success
27143 
 
27144 
  def read(self, iprot):
27145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27147 
      return
27148 
    iprot.readStructBegin()
27149 
    while True:
27150 
      (fname, ftype, fid) = iprot.readFieldBegin()
27151 
      if ftype == TType.STOP:
27152 
        break
27153 
      if fid == 0:
27154 
        if ftype == TType.LIST:
27155 
          self.success = []
6031 rajveer 27156 
          (_etype623, _size620) = iprot.readListBegin()
27157 
          for _i624 in xrange(_size620):
27158 
            _elem625 = UserWalletHistory()
27159 
            _elem625.read(iprot)
27160 
            self.success.append(_elem625)
6000 mandeep.dh 27161 
          iprot.readListEnd()
27162 
        else:
27163 
          iprot.skip(ftype)
27164 
      else:
27165 
        iprot.skip(ftype)
27166 
      iprot.readFieldEnd()
27167 
    iprot.readStructEnd()
27168 
 
27169 
  def write(self, oprot):
27170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27172 
      return
6031 rajveer 27173 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27174 
    if self.success is not None:
27175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27176 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 27177 
      for iter626 in self.success:
27178 
        iter626.write(oprot)
6000 mandeep.dh 27179 
      oprot.writeListEnd()
27180 
      oprot.writeFieldEnd()
27181 
    oprot.writeFieldStop()
27182 
    oprot.writeStructEnd()
27183 
 
27184 
  def validate(self):
27185 
    return
27186 
 
27187 
 
27188 
  def __repr__(self):
27189 
    L = ['%s=%r' % (key, value)
27190 
      for key, value in self.__dict__.iteritems()]
27191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27192 
 
27193 
  def __eq__(self, other):
27194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27195 
 
27196 
  def __ne__(self, other):
27197 
    return not (self == other)
6048 rajveer 27198 
 
6050 anupam.sin 27199 
class getRechargeOrdersForTransaction_args:
27200 
  """
27201 
  Attributes:
27202 
   - txnId
27203 
  """
27204 
 
27205 
  thrift_spec = (
27206 
    None, # 0
27207 
    (1, TType.I64, 'txnId', None, None, ), # 1
27208 
  )
27209 
 
27210 
  def __init__(self, txnId=None,):
27211 
    self.txnId = txnId
27212 
 
27213 
  def read(self, iprot):
27214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27216 
      return
27217 
    iprot.readStructBegin()
27218 
    while True:
27219 
      (fname, ftype, fid) = iprot.readFieldBegin()
27220 
      if ftype == TType.STOP:
27221 
        break
27222 
      if fid == 1:
27223 
        if ftype == TType.I64:
27224 
          self.txnId = iprot.readI64();
27225 
        else:
27226 
          iprot.skip(ftype)
27227 
      else:
27228 
        iprot.skip(ftype)
27229 
      iprot.readFieldEnd()
27230 
    iprot.readStructEnd()
27231 
 
27232 
  def write(self, oprot):
27233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27235 
      return
27236 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27237 
    if self.txnId is not None:
27238 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27239 
      oprot.writeI64(self.txnId)
27240 
      oprot.writeFieldEnd()
27241 
    oprot.writeFieldStop()
27242 
    oprot.writeStructEnd()
27243 
 
27244 
  def validate(self):
27245 
    return
27246 
 
27247 
 
27248 
  def __repr__(self):
27249 
    L = ['%s=%r' % (key, value)
27250 
      for key, value in self.__dict__.iteritems()]
27251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27252 
 
27253 
  def __eq__(self, other):
27254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27255 
 
27256 
  def __ne__(self, other):
27257 
    return not (self == other)
27258 
 
27259 
class getRechargeOrdersForTransaction_result:
27260 
  """
27261 
  Attributes:
27262 
   - success
27263 
   - ex
27264 
  """
27265 
 
27266 
  thrift_spec = (
27267 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27268 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27269 
  )
27270 
 
27271 
  def __init__(self, success=None, ex=None,):
27272 
    self.success = success
27273 
    self.ex = ex
27274 
 
27275 
  def read(self, iprot):
27276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27278 
      return
27279 
    iprot.readStructBegin()
27280 
    while True:
27281 
      (fname, ftype, fid) = iprot.readFieldBegin()
27282 
      if ftype == TType.STOP:
27283 
        break
27284 
      if fid == 0:
27285 
        if ftype == TType.STRUCT:
27286 
          self.success = RechargeOrder()
27287 
          self.success.read(iprot)
27288 
        else:
27289 
          iprot.skip(ftype)
27290 
      elif fid == 1:
27291 
        if ftype == TType.STRUCT:
27292 
          self.ex = TransactionServiceException()
27293 
          self.ex.read(iprot)
27294 
        else:
27295 
          iprot.skip(ftype)
27296 
      else:
27297 
        iprot.skip(ftype)
27298 
      iprot.readFieldEnd()
27299 
    iprot.readStructEnd()
27300 
 
27301 
  def write(self, oprot):
27302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27304 
      return
27305 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27306 
    if self.success is not None:
27307 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27308 
      self.success.write(oprot)
27309 
      oprot.writeFieldEnd()
27310 
    if self.ex is not None:
27311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27312 
      self.ex.write(oprot)
27313 
      oprot.writeFieldEnd()
27314 
    oprot.writeFieldStop()
27315 
    oprot.writeStructEnd()
27316 
 
27317 
  def validate(self):
27318 
    return
27319 
 
27320 
 
27321 
  def __repr__(self):
27322 
    L = ['%s=%r' % (key, value)
27323 
      for key, value in self.__dict__.iteritems()]
27324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27325 
 
27326 
  def __eq__(self, other):
27327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27328 
 
27329 
  def __ne__(self, other):
27330 
    return not (self == other)
27331 
 
6048 rajveer 27332 
class getServiceProviders_args:
27333 
  """
27334 
  Attributes:
27335 
   - rechargeType
27336 
  """
27337 
 
27338 
  thrift_spec = (
27339 
    None, # 0
27340 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27341 
  )
27342 
 
27343 
  def __init__(self, rechargeType=None,):
27344 
    self.rechargeType = rechargeType
27345 
 
27346 
  def read(self, iprot):
27347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27349 
      return
27350 
    iprot.readStructBegin()
27351 
    while True:
27352 
      (fname, ftype, fid) = iprot.readFieldBegin()
27353 
      if ftype == TType.STOP:
27354 
        break
27355 
      if fid == 1:
27356 
        if ftype == TType.I32:
27357 
          self.rechargeType = iprot.readI32();
27358 
        else:
27359 
          iprot.skip(ftype)
27360 
      else:
27361 
        iprot.skip(ftype)
27362 
      iprot.readFieldEnd()
27363 
    iprot.readStructEnd()
27364 
 
27365 
  def write(self, oprot):
27366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27368 
      return
27369 
    oprot.writeStructBegin('getServiceProviders_args')
27370 
    if self.rechargeType is not None:
27371 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27372 
      oprot.writeI32(self.rechargeType)
27373 
      oprot.writeFieldEnd()
27374 
    oprot.writeFieldStop()
27375 
    oprot.writeStructEnd()
27376 
 
27377 
  def validate(self):
27378 
    return
27379 
 
27380 
 
27381 
  def __repr__(self):
27382 
    L = ['%s=%r' % (key, value)
27383 
      for key, value in self.__dict__.iteritems()]
27384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27385 
 
27386 
  def __eq__(self, other):
27387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27388 
 
27389 
  def __ne__(self, other):
27390 
    return not (self == other)
27391 
 
27392 
class getServiceProviders_result:
27393 
  """
27394 
  Attributes:
27395 
   - success
27396 
  """
27397 
 
27398 
  thrift_spec = (
27399 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27400 
  )
27401 
 
27402 
  def __init__(self, success=None,):
27403 
    self.success = success
27404 
 
27405 
  def read(self, iprot):
27406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27408 
      return
27409 
    iprot.readStructBegin()
27410 
    while True:
27411 
      (fname, ftype, fid) = iprot.readFieldBegin()
27412 
      if ftype == TType.STOP:
27413 
        break
27414 
      if fid == 0:
27415 
        if ftype == TType.MAP:
27416 
          self.success = {}
27417 
          (_ktype628, _vtype629, _size627 ) = iprot.readMapBegin()
27418 
          for _i631 in xrange(_size627):
27419 
            _key632 = iprot.readI64();
27420 
            _val633 = iprot.readString();
27421 
            self.success[_key632] = _val633
27422 
          iprot.readMapEnd()
27423 
        else:
27424 
          iprot.skip(ftype)
27425 
      else:
27426 
        iprot.skip(ftype)
27427 
      iprot.readFieldEnd()
27428 
    iprot.readStructEnd()
27429 
 
27430 
  def write(self, oprot):
27431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27433 
      return
27434 
    oprot.writeStructBegin('getServiceProviders_result')
27435 
    if self.success is not None:
27436 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27437 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
27438 
      for kiter634,viter635 in self.success.items():
27439 
        oprot.writeI64(kiter634)
27440 
        oprot.writeString(viter635)
27441 
      oprot.writeMapEnd()
27442 
      oprot.writeFieldEnd()
27443 
    oprot.writeFieldStop()
27444 
    oprot.writeStructEnd()
27445 
 
27446 
  def validate(self):
27447 
    return
27448 
 
27449 
 
27450 
  def __repr__(self):
27451 
    L = ['%s=%r' % (key, value)
27452 
      for key, value in self.__dict__.iteritems()]
27453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27454 
 
27455 
  def __eq__(self, other):
27456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27457 
 
27458 
  def __ne__(self, other):
27459 
    return not (self == other)
27460 
 
27461 
class getServiceProviderForDevice_args:
27462 
  """
27463 
  Attributes:
6049 rajveer 27464 
   - rechargeType
6048 rajveer 27465 
   - deviceNumber
27466 
  """
27467 
 
27468 
  thrift_spec = (
27469 
    None, # 0
6049 rajveer 27470 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27471 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27472 
  )
27473 
 
6049 rajveer 27474 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27475 
    self.rechargeType = rechargeType
6048 rajveer 27476 
    self.deviceNumber = deviceNumber
27477 
 
27478 
  def read(self, iprot):
27479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27481 
      return
27482 
    iprot.readStructBegin()
27483 
    while True:
27484 
      (fname, ftype, fid) = iprot.readFieldBegin()
27485 
      if ftype == TType.STOP:
27486 
        break
27487 
      if fid == 1:
6049 rajveer 27488 
        if ftype == TType.I32:
27489 
          self.rechargeType = iprot.readI32();
27490 
        else:
27491 
          iprot.skip(ftype)
27492 
      elif fid == 2:
6048 rajveer 27493 
        if ftype == TType.STRING:
27494 
          self.deviceNumber = iprot.readString();
27495 
        else:
27496 
          iprot.skip(ftype)
27497 
      else:
27498 
        iprot.skip(ftype)
27499 
      iprot.readFieldEnd()
27500 
    iprot.readStructEnd()
27501 
 
27502 
  def write(self, oprot):
27503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27505 
      return
27506 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27507 
    if self.rechargeType is not None:
27508 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27509 
      oprot.writeI32(self.rechargeType)
27510 
      oprot.writeFieldEnd()
6048 rajveer 27511 
    if self.deviceNumber is not None:
6049 rajveer 27512 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27513 
      oprot.writeString(self.deviceNumber)
27514 
      oprot.writeFieldEnd()
27515 
    oprot.writeFieldStop()
27516 
    oprot.writeStructEnd()
27517 
 
27518 
  def validate(self):
27519 
    return
27520 
 
27521 
 
27522 
  def __repr__(self):
27523 
    L = ['%s=%r' % (key, value)
27524 
      for key, value in self.__dict__.iteritems()]
27525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27526 
 
27527 
  def __eq__(self, other):
27528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27529 
 
27530 
  def __ne__(self, other):
27531 
    return not (self == other)
27532 
 
27533 
class getServiceProviderForDevice_result:
27534 
  """
27535 
  Attributes:
27536 
   - success
27537 
  """
27538 
 
27539 
  thrift_spec = (
27540 
    (0, TType.I64, 'success', None, None, ), # 0
27541 
  )
27542 
 
27543 
  def __init__(self, success=None,):
27544 
    self.success = success
27545 
 
27546 
  def read(self, iprot):
27547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27549 
      return
27550 
    iprot.readStructBegin()
27551 
    while True:
27552 
      (fname, ftype, fid) = iprot.readFieldBegin()
27553 
      if ftype == TType.STOP:
27554 
        break
27555 
      if fid == 0:
27556 
        if ftype == TType.I64:
27557 
          self.success = iprot.readI64();
27558 
        else:
27559 
          iprot.skip(ftype)
27560 
      else:
27561 
        iprot.skip(ftype)
27562 
      iprot.readFieldEnd()
27563 
    iprot.readStructEnd()
27564 
 
27565 
  def write(self, oprot):
27566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27568 
      return
27569 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27570 
    if self.success is not None:
27571 
      oprot.writeFieldBegin('success', TType.I64, 0)
27572 
      oprot.writeI64(self.success)
27573 
      oprot.writeFieldEnd()
27574 
    oprot.writeFieldStop()
27575 
    oprot.writeStructEnd()
27576 
 
27577 
  def validate(self):
27578 
    return
27579 
 
27580 
 
27581 
  def __repr__(self):
27582 
    L = ['%s=%r' % (key, value)
27583 
      for key, value in self.__dict__.iteritems()]
27584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27585 
 
27586 
  def __eq__(self, other):
27587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27588 
 
27589 
  def __ne__(self, other):
27590 
    return not (self == other)
6094 rajveer 27591 
 
27592 
class getRechargeOrdersForDevice_args:
27593 
  """
27594 
  Attributes:
27595 
   - deviceNumber
27596 
  """
27597 
 
27598 
  thrift_spec = (
27599 
    None, # 0
27600 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27601 
  )
27602 
 
27603 
  def __init__(self, deviceNumber=None,):
27604 
    self.deviceNumber = deviceNumber
27605 
 
27606 
  def read(self, iprot):
27607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27609 
      return
27610 
    iprot.readStructBegin()
27611 
    while True:
27612 
      (fname, ftype, fid) = iprot.readFieldBegin()
27613 
      if ftype == TType.STOP:
27614 
        break
27615 
      if fid == 1:
27616 
        if ftype == TType.STRING:
27617 
          self.deviceNumber = iprot.readString();
27618 
        else:
27619 
          iprot.skip(ftype)
27620 
      else:
27621 
        iprot.skip(ftype)
27622 
      iprot.readFieldEnd()
27623 
    iprot.readStructEnd()
27624 
 
27625 
  def write(self, oprot):
27626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27628 
      return
27629 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27630 
    if self.deviceNumber is not None:
27631 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27632 
      oprot.writeString(self.deviceNumber)
27633 
      oprot.writeFieldEnd()
27634 
    oprot.writeFieldStop()
27635 
    oprot.writeStructEnd()
27636 
 
27637 
  def validate(self):
27638 
    return
27639 
 
27640 
 
27641 
  def __repr__(self):
27642 
    L = ['%s=%r' % (key, value)
27643 
      for key, value in self.__dict__.iteritems()]
27644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27645 
 
27646 
  def __eq__(self, other):
27647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27648 
 
27649 
  def __ne__(self, other):
27650 
    return not (self == other)
27651 
 
27652 
class getRechargeOrdersForDevice_result:
27653 
  """
27654 
  Attributes:
27655 
   - success
27656 
  """
27657 
 
27658 
  thrift_spec = (
27659 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27660 
  )
27661 
 
27662 
  def __init__(self, success=None,):
27663 
    self.success = success
27664 
 
27665 
  def read(self, iprot):
27666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27668 
      return
27669 
    iprot.readStructBegin()
27670 
    while True:
27671 
      (fname, ftype, fid) = iprot.readFieldBegin()
27672 
      if ftype == TType.STOP:
27673 
        break
27674 
      if fid == 0:
27675 
        if ftype == TType.LIST:
27676 
          self.success = []
27677 
          (_etype639, _size636) = iprot.readListBegin()
27678 
          for _i640 in xrange(_size636):
27679 
            _elem641 = RechargeOrder()
27680 
            _elem641.read(iprot)
27681 
            self.success.append(_elem641)
27682 
          iprot.readListEnd()
27683 
        else:
27684 
          iprot.skip(ftype)
27685 
      else:
27686 
        iprot.skip(ftype)
27687 
      iprot.readFieldEnd()
27688 
    iprot.readStructEnd()
27689 
 
27690 
  def write(self, oprot):
27691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27693 
      return
27694 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
27695 
    if self.success is not None:
27696 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27697 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27698 
      for iter642 in self.success:
27699 
        iter642.write(oprot)
27700 
      oprot.writeListEnd()
27701 
      oprot.writeFieldEnd()
27702 
    oprot.writeFieldStop()
27703 
    oprot.writeStructEnd()
27704 
 
27705 
  def validate(self):
27706 
    return
27707 
 
27708 
 
27709 
  def __repr__(self):
27710 
    L = ['%s=%r' % (key, value)
27711 
      for key, value in self.__dict__.iteritems()]
27712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27713 
 
27714 
  def __eq__(self, other):
27715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27716 
 
27717 
  def __ne__(self, other):
27718 
    return not (self == other)
27719 
 
27720 
class addAmountToWallet_args:
27721 
  """
27722 
  Attributes:
27723 
   - userId
27724 
   - orderId
27725 
   - amount
27726 
  """
27727 
 
27728 
  thrift_spec = (
27729 
    None, # 0
27730 
    (1, TType.I64, 'userId', None, None, ), # 1
27731 
    (2, TType.I64, 'orderId', None, None, ), # 2
27732 
    (3, TType.I64, 'amount', None, None, ), # 3
27733 
  )
27734 
 
27735 
  def __init__(self, userId=None, orderId=None, amount=None,):
27736 
    self.userId = userId
27737 
    self.orderId = orderId
27738 
    self.amount = amount
27739 
 
27740 
  def read(self, iprot):
27741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27743 
      return
27744 
    iprot.readStructBegin()
27745 
    while True:
27746 
      (fname, ftype, fid) = iprot.readFieldBegin()
27747 
      if ftype == TType.STOP:
27748 
        break
27749 
      if fid == 1:
27750 
        if ftype == TType.I64:
27751 
          self.userId = iprot.readI64();
27752 
        else:
27753 
          iprot.skip(ftype)
27754 
      elif fid == 2:
27755 
        if ftype == TType.I64:
27756 
          self.orderId = iprot.readI64();
27757 
        else:
27758 
          iprot.skip(ftype)
27759 
      elif fid == 3:
27760 
        if ftype == TType.I64:
27761 
          self.amount = iprot.readI64();
27762 
        else:
27763 
          iprot.skip(ftype)
27764 
      else:
27765 
        iprot.skip(ftype)
27766 
      iprot.readFieldEnd()
27767 
    iprot.readStructEnd()
27768 
 
27769 
  def write(self, oprot):
27770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27772 
      return
27773 
    oprot.writeStructBegin('addAmountToWallet_args')
27774 
    if self.userId is not None:
27775 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27776 
      oprot.writeI64(self.userId)
27777 
      oprot.writeFieldEnd()
27778 
    if self.orderId is not None:
27779 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
27780 
      oprot.writeI64(self.orderId)
27781 
      oprot.writeFieldEnd()
27782 
    if self.amount is not None:
27783 
      oprot.writeFieldBegin('amount', TType.I64, 3)
27784 
      oprot.writeI64(self.amount)
27785 
      oprot.writeFieldEnd()
27786 
    oprot.writeFieldStop()
27787 
    oprot.writeStructEnd()
27788 
 
27789 
  def validate(self):
27790 
    return
27791 
 
27792 
 
27793 
  def __repr__(self):
27794 
    L = ['%s=%r' % (key, value)
27795 
      for key, value in self.__dict__.iteritems()]
27796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27797 
 
27798 
  def __eq__(self, other):
27799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27800 
 
27801 
  def __ne__(self, other):
27802 
    return not (self == other)
27803 
 
27804 
class addAmountToWallet_result:
27805 
 
27806 
  thrift_spec = (
27807 
  )
27808 
 
27809 
  def read(self, iprot):
27810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27812 
      return
27813 
    iprot.readStructBegin()
27814 
    while True:
27815 
      (fname, ftype, fid) = iprot.readFieldBegin()
27816 
      if ftype == TType.STOP:
27817 
        break
27818 
      else:
27819 
        iprot.skip(ftype)
27820 
      iprot.readFieldEnd()
27821 
    iprot.readStructEnd()
27822 
 
27823 
  def write(self, oprot):
27824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27826 
      return
27827 
    oprot.writeStructBegin('addAmountToWallet_result')
27828 
    oprot.writeFieldStop()
27829 
    oprot.writeStructEnd()
27830 
 
27831 
  def validate(self):
27832 
    return
27833 
 
27834 
 
27835 
  def __repr__(self):
27836 
    L = ['%s=%r' % (key, value)
27837 
      for key, value in self.__dict__.iteritems()]
27838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27839 
 
27840 
  def __eq__(self, other):
27841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27842 
 
27843 
  def __ne__(self, other):
27844 
    return not (self == other)
6154 rajveer 27845 
 
27846 
class getRechargeOrdersForStatus_args:
27847 
  """
27848 
  Attributes:
27849 
   - status
27850 
  """
27851 
 
27852 
  thrift_spec = (
27853 
    None, # 0
27854 
    (1, TType.I64, 'status', None, None, ), # 1
27855 
  )
27856 
 
27857 
  def __init__(self, status=None,):
27858 
    self.status = status
27859 
 
27860 
  def read(self, iprot):
27861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27863 
      return
27864 
    iprot.readStructBegin()
27865 
    while True:
27866 
      (fname, ftype, fid) = iprot.readFieldBegin()
27867 
      if ftype == TType.STOP:
27868 
        break
27869 
      if fid == 1:
27870 
        if ftype == TType.I64:
27871 
          self.status = iprot.readI64();
27872 
        else:
27873 
          iprot.skip(ftype)
27874 
      else:
27875 
        iprot.skip(ftype)
27876 
      iprot.readFieldEnd()
27877 
    iprot.readStructEnd()
27878 
 
27879 
  def write(self, oprot):
27880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27882 
      return
27883 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
27884 
    if self.status is not None:
27885 
      oprot.writeFieldBegin('status', TType.I64, 1)
27886 
      oprot.writeI64(self.status)
27887 
      oprot.writeFieldEnd()
27888 
    oprot.writeFieldStop()
27889 
    oprot.writeStructEnd()
27890 
 
27891 
  def validate(self):
27892 
    return
27893 
 
27894 
 
27895 
  def __repr__(self):
27896 
    L = ['%s=%r' % (key, value)
27897 
      for key, value in self.__dict__.iteritems()]
27898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27899 
 
27900 
  def __eq__(self, other):
27901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27902 
 
27903 
  def __ne__(self, other):
27904 
    return not (self == other)
27905 
 
27906 
class getRechargeOrdersForStatus_result:
27907 
  """
27908 
  Attributes:
27909 
   - success
27910 
  """
27911 
 
27912 
  thrift_spec = (
27913 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27914 
  )
27915 
 
27916 
  def __init__(self, success=None,):
27917 
    self.success = success
27918 
 
27919 
  def read(self, iprot):
27920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27922 
      return
27923 
    iprot.readStructBegin()
27924 
    while True:
27925 
      (fname, ftype, fid) = iprot.readFieldBegin()
27926 
      if ftype == TType.STOP:
27927 
        break
27928 
      if fid == 0:
27929 
        if ftype == TType.LIST:
27930 
          self.success = []
27931 
          (_etype646, _size643) = iprot.readListBegin()
27932 
          for _i647 in xrange(_size643):
27933 
            _elem648 = RechargeOrder()
27934 
            _elem648.read(iprot)
27935 
            self.success.append(_elem648)
27936 
          iprot.readListEnd()
27937 
        else:
27938 
          iprot.skip(ftype)
27939 
      else:
27940 
        iprot.skip(ftype)
27941 
      iprot.readFieldEnd()
27942 
    iprot.readStructEnd()
27943 
 
27944 
  def write(self, oprot):
27945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27947 
      return
27948 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
27949 
    if self.success is not None:
27950 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27951 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27952 
      for iter649 in self.success:
27953 
        iter649.write(oprot)
27954 
      oprot.writeListEnd()
27955 
      oprot.writeFieldEnd()
27956 
    oprot.writeFieldStop()
27957 
    oprot.writeStructEnd()
27958 
 
27959 
  def validate(self):
27960 
    return
27961 
 
27962 
 
27963 
  def __repr__(self):
27964 
    L = ['%s=%r' % (key, value)
27965 
      for key, value in self.__dict__.iteritems()]
27966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27967 
 
27968 
  def __eq__(self, other):
27969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27970 
 
27971 
  def __ne__(self, other):
27972 
    return not (self == other)