Subversion Repositories SmartDukaan

Rev

Rev 6985 | Rev 7026 | 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 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    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.
527 
    Returns the final flag status.
528 
    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 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    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 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    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 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	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 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    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 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
6988 rajveer 1475 
  def retrieveInvoice(self, orderId):
1476 
    """
1477 
    Parameters:
1478 
     - orderId
1479 
    """
1480 
    pass
6985 anupam.sin 1481 
 
6988 rajveer 1482 
 
3376 rajveer 1483 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1484 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1485 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1486 
 
1487 
  def createTransaction(self, transaction):
1488 
    """
1489 
    Parameters:
1490 
     - transaction
1491 
    """
1492 
    self.send_createTransaction(transaction)
132 ashish 1493 
    return self.recv_createTransaction()
94 ashish 1494 
 
1495 
  def send_createTransaction(self, transaction):
1496 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1497 
    args = createTransaction_args()
1498 
    args.transaction = transaction
1499 
    args.write(self._oprot)
1500 
    self._oprot.writeMessageEnd()
1501 
    self._oprot.trans.flush()
1502 
 
1503 
  def recv_createTransaction(self, ):
1504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1505 
    if mtype == TMessageType.EXCEPTION:
1506 
      x = TApplicationException()
1507 
      x.read(self._iprot)
1508 
      self._iprot.readMessageEnd()
1509 
      raise x
1510 
    result = createTransaction_result()
1511 
    result.read(self._iprot)
1512 
    self._iprot.readMessageEnd()
3431 rajveer 1513 
    if result.success is not None:
132 ashish 1514 
      return result.success
3431 rajveer 1515 
    if result.ex is not None:
94 ashish 1516 
      raise result.ex
132 ashish 1517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1518 
 
1519 
  def getTransaction(self, id):
1520 
    """
1521 
    Parameters:
1522 
     - id
1523 
    """
1524 
    self.send_getTransaction(id)
1525 
    return self.recv_getTransaction()
1526 
 
1527 
  def send_getTransaction(self, id):
1528 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1529 
    args = getTransaction_args()
1530 
    args.id = id
1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_getTransaction(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = getTransaction_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
3431 rajveer 1545 
    if result.success is not None:
94 ashish 1546 
      return result.success
3431 rajveer 1547 
    if result.ex is not None:
94 ashish 1548 
      raise result.ex
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1550 
 
1551 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1552 
    """
1553 
    Parameters:
1554 
     - customerId
1555 
     - from_date
1556 
     - to_date
1557 
     - status
1558 
    """
1559 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1560 
    return self.recv_getTransactionsForCustomer()
1561 
 
1562 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1563 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1564 
    args = getTransactionsForCustomer_args()
1565 
    args.customerId = customerId
1566 
    args.from_date = from_date
1567 
    args.to_date = to_date
1568 
    args.status = status
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_getTransactionsForCustomer(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = getTransactionsForCustomer_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
3431 rajveer 1583 
    if result.success is not None:
94 ashish 1584 
      return result.success
3431 rajveer 1585 
    if result.ex is not None:
94 ashish 1586 
      raise result.ex
1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1588 
 
132 ashish 1589 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1590 
    """
1591 
    Parameters:
1592 
     - shoppingCartId
1593 
    """
1594 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1595 
    return self.recv_getTransactionsForShoppingCartId()
1596 
 
1597 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1598 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1599 
    args = getTransactionsForShoppingCartId_args()
1600 
    args.shoppingCartId = shoppingCartId
1601 
    args.write(self._oprot)
1602 
    self._oprot.writeMessageEnd()
1603 
    self._oprot.trans.flush()
1604 
 
1605 
  def recv_getTransactionsForShoppingCartId(self, ):
1606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1607 
    if mtype == TMessageType.EXCEPTION:
1608 
      x = TApplicationException()
1609 
      x.read(self._iprot)
1610 
      self._iprot.readMessageEnd()
1611 
      raise x
1612 
    result = getTransactionsForShoppingCartId_result()
1613 
    result.read(self._iprot)
1614 
    self._iprot.readMessageEnd()
3431 rajveer 1615 
    if result.success is not None:
132 ashish 1616 
      return result.success
3431 rajveer 1617 
    if result.ex is not None:
132 ashish 1618 
      raise result.ex
1619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1620 
 
94 ashish 1621 
  def getTransactionStatus(self, transactionId):
1622 
    """
1623 
    Parameters:
1624 
     - transactionId
1625 
    """
1626 
    self.send_getTransactionStatus(transactionId)
1627 
    return self.recv_getTransactionStatus()
1628 
 
1629 
  def send_getTransactionStatus(self, transactionId):
1630 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1631 
    args = getTransactionStatus_args()
1632 
    args.transactionId = transactionId
1633 
    args.write(self._oprot)
1634 
    self._oprot.writeMessageEnd()
1635 
    self._oprot.trans.flush()
1636 
 
1637 
  def recv_getTransactionStatus(self, ):
1638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1639 
    if mtype == TMessageType.EXCEPTION:
1640 
      x = TApplicationException()
1641 
      x.read(self._iprot)
1642 
      self._iprot.readMessageEnd()
1643 
      raise x
1644 
    result = getTransactionStatus_result()
1645 
    result.read(self._iprot)
1646 
    self._iprot.readMessageEnd()
3431 rajveer 1647 
    if result.success is not None:
94 ashish 1648 
      return result.success
3431 rajveer 1649 
    if result.ex is not None:
94 ashish 1650 
      raise result.ex
1651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1652 
 
5527 anupam.sin 1653 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1654 
    """
1655 
    Parameters:
1656 
     - transactionId
1657 
     - status
1658 
     - description
5527 anupam.sin 1659 
     - pickUp
1660 
     - orderType
94 ashish 1661 
    """
5527 anupam.sin 1662 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1663 
    return self.recv_changeTransactionStatus()
1664 
 
5527 anupam.sin 1665 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1666 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1667 
    args = changeTransactionStatus_args()
1668 
    args.transactionId = transactionId
1669 
    args.status = status
1670 
    args.description = description
5527 anupam.sin 1671 
    args.pickUp = pickUp
1672 
    args.orderType = orderType
94 ashish 1673 
    args.write(self._oprot)
1674 
    self._oprot.writeMessageEnd()
1675 
    self._oprot.trans.flush()
1676 
 
1677 
  def recv_changeTransactionStatus(self, ):
1678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1679 
    if mtype == TMessageType.EXCEPTION:
1680 
      x = TApplicationException()
1681 
      x.read(self._iprot)
1682 
      self._iprot.readMessageEnd()
1683 
      raise x
1684 
    result = changeTransactionStatus_result()
1685 
    result.read(self._iprot)
1686 
    self._iprot.readMessageEnd()
3431 rajveer 1687 
    if result.success is not None:
94 ashish 1688 
      return result.success
3431 rajveer 1689 
    if result.ex is not None:
94 ashish 1690 
      raise result.ex
1691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1692 
 
1398 varun.gupt 1693 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1694 
    """
1695 
    Parameters:
1696 
     - transactionId
1697 
    """
1398 varun.gupt 1698 
    self.send_enqueueTransactionInfoEmail(transactionId)
1699 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1700 
 
1398 varun.gupt 1701 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1702 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1703 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1704 
    args.transactionId = transactionId
1705 
    args.write(self._oprot)
1706 
    self._oprot.writeMessageEnd()
1707 
    self._oprot.trans.flush()
1708 
 
1398 varun.gupt 1709 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1711 
    if mtype == TMessageType.EXCEPTION:
1712 
      x = TApplicationException()
1713 
      x.read(self._iprot)
1714 
      self._iprot.readMessageEnd()
1715 
      raise x
1398 varun.gupt 1716 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1717 
    result.read(self._iprot)
1718 
    self._iprot.readMessageEnd()
3431 rajveer 1719 
    if result.success is not None:
1382 varun.gupt 1720 
      return result.success
3431 rajveer 1721 
    if result.ex is not None:
1382 varun.gupt 1722 
      raise result.ex
1398 varun.gupt 1723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1724 
 
4801 anupam.sin 1725 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1726 
    """
1727 
    Parameters:
4801 anupam.sin 1728 
     - statuses
483 rajveer 1729 
     - from_date
1730 
     - to_date
1731 
     - warehouse_id
94 ashish 1732 
    """
4801 anupam.sin 1733 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1734 
    return self.recv_getAllOrders()
94 ashish 1735 
 
4801 anupam.sin 1736 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1737 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1738 
    args = getAllOrders_args()
4801 anupam.sin 1739 
    args.statuses = statuses
483 rajveer 1740 
    args.from_date = from_date
1741 
    args.to_date = to_date
1742 
    args.warehouse_id = warehouse_id
94 ashish 1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
483 rajveer 1747 
  def recv_getAllOrders(self, ):
94 ashish 1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
483 rajveer 1754 
    result = getAllOrders_result()
94 ashish 1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
3431 rajveer 1757 
    if result.success is not None:
94 ashish 1758 
      return result.success
3431 rajveer 1759 
    if result.ex is not None:
94 ashish 1760 
      raise result.ex
483 rajveer 1761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1762 
 
4133 chandransh 1763 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1764 
    """
1765 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1766 
    Pass the status as null and the limit as 0 to ignore them.
1767 
 
1768 
    Parameters:
1769 
     - statuses
1770 
     - offset
1771 
     - limit
1772 
     - warehouse_id
1773 
    """
1774 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1775 
    return self.recv_getOrdersInBatch()
1776 
 
1777 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1778 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1779 
    args = getOrdersInBatch_args()
1780 
    args.statuses = statuses
1781 
    args.offset = offset
1782 
    args.limit = limit
1783 
    args.warehouse_id = warehouse_id
1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
1788 
  def recv_getOrdersInBatch(self, ):
1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
1795 
    result = getOrdersInBatch_result()
1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
1798 
    if result.success is not None:
1799 
      return result.success
1800 
    if result.ex is not None:
1801 
      raise result.ex
1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1803 
 
1804 
  def getOrderCount(self, statuses, warehouseId):
1805 
    """
1806 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1807 
 
1808 
    Parameters:
1809 
     - statuses
1810 
     - warehouseId
1811 
    """
1812 
    self.send_getOrderCount(statuses, warehouseId)
1813 
    return self.recv_getOrderCount()
1814 
 
1815 
  def send_getOrderCount(self, statuses, warehouseId):
1816 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1817 
    args = getOrderCount_args()
1818 
    args.statuses = statuses
1819 
    args.warehouseId = warehouseId
1820 
    args.write(self._oprot)
1821 
    self._oprot.writeMessageEnd()
1822 
    self._oprot.trans.flush()
1823 
 
1824 
  def recv_getOrderCount(self, ):
1825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1826 
    if mtype == TMessageType.EXCEPTION:
1827 
      x = TApplicationException()
1828 
      x.read(self._iprot)
1829 
      self._iprot.readMessageEnd()
1830 
      raise x
1831 
    result = getOrderCount_result()
1832 
    result.read(self._iprot)
1833 
    self._iprot.readMessageEnd()
1834 
    if result.success is not None:
1835 
      return result.success
1836 
    if result.ex is not None:
1837 
      raise result.ex
1838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1839 
 
999 varun.gupt 1840 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1841 
    """
1132 chandransh 1842 
    Returns orders within a range of their billing dates
3431 rajveer 1843 
 
999 varun.gupt 1844 
    Parameters:
1845 
     - status
1846 
     - start_billing_date
1847 
     - end_billing_date
1848 
     - warehouse_id
1849 
    """
1850 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1851 
    return self.recv_getOrdersByBillingDate()
1852 
 
1853 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1854 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1855 
    args = getOrdersByBillingDate_args()
1856 
    args.status = status
1857 
    args.start_billing_date = start_billing_date
1858 
    args.end_billing_date = end_billing_date
1859 
    args.warehouse_id = warehouse_id
1860 
    args.write(self._oprot)
1861 
    self._oprot.writeMessageEnd()
1862 
    self._oprot.trans.flush()
1863 
 
1864 
  def recv_getOrdersByBillingDate(self, ):
1865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1866 
    if mtype == TMessageType.EXCEPTION:
1867 
      x = TApplicationException()
1868 
      x.read(self._iprot)
1869 
      self._iprot.readMessageEnd()
1870 
      raise x
1871 
    result = getOrdersByBillingDate_result()
1872 
    result.read(self._iprot)
1873 
    self._iprot.readMessageEnd()
3431 rajveer 1874 
    if result.success is not None:
999 varun.gupt 1875 
      return result.success
3431 rajveer 1876 
    if result.ex is not None:
999 varun.gupt 1877 
      raise result.ex
1878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1879 
 
3451 chandransh 1880 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1881 
    """
1882 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1883 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1884 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1885 
 
3427 chandransh 1886 
    Parameters:
1887 
     - fromShippingDate
1888 
     - toShippingDate
1889 
     - providerId
1890 
     - warehouseId
3451 chandransh 1891 
     - cod
3427 chandransh 1892 
    """
3451 chandransh 1893 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1894 
    return self.recv_getOrdersByShippingDate()
1895 
 
3451 chandransh 1896 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1897 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1898 
    args = getOrdersByShippingDate_args()
1899 
    args.fromShippingDate = fromShippingDate
1900 
    args.toShippingDate = toShippingDate
1901 
    args.providerId = providerId
1902 
    args.warehouseId = warehouseId
3451 chandransh 1903 
    args.cod = cod
3427 chandransh 1904 
    args.write(self._oprot)
1905 
    self._oprot.writeMessageEnd()
1906 
    self._oprot.trans.flush()
1907 
 
1908 
  def recv_getOrdersByShippingDate(self, ):
1909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1910 
    if mtype == TMessageType.EXCEPTION:
1911 
      x = TApplicationException()
1912 
      x.read(self._iprot)
1913 
      self._iprot.readMessageEnd()
1914 
      raise x
1915 
    result = getOrdersByShippingDate_result()
1916 
    result.read(self._iprot)
1917 
    self._iprot.readMessageEnd()
3431 rajveer 1918 
    if result.success is not None:
3427 chandransh 1919 
      return result.success
3431 rajveer 1920 
    if result.ex is not None:
3427 chandransh 1921 
      raise result.ex
1922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1923 
 
1382 varun.gupt 1924 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1925 
    """
1926 
    Returns order ids for orders which can be returned
3431 rajveer 1927 
 
1382 varun.gupt 1928 
    Parameters:
1929 
     - customer_id
1930 
     - limit
1931 
    """
1932 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1933 
    return self.recv_getReturnableOrdersForCustomer()
1934 
 
1935 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1936 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1937 
    args = getReturnableOrdersForCustomer_args()
1938 
    args.customer_id = customer_id
1939 
    args.limit = limit
1940 
    args.write(self._oprot)
1941 
    self._oprot.writeMessageEnd()
1942 
    self._oprot.trans.flush()
1943 
 
1944 
  def recv_getReturnableOrdersForCustomer(self, ):
1945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1946 
    if mtype == TMessageType.EXCEPTION:
1947 
      x = TApplicationException()
1948 
      x.read(self._iprot)
1949 
      self._iprot.readMessageEnd()
1950 
      raise x
1951 
    result = getReturnableOrdersForCustomer_result()
1952 
    result.read(self._iprot)
1953 
    self._iprot.readMessageEnd()
3431 rajveer 1954 
    if result.success is not None:
1382 varun.gupt 1955 
      return result.success
3431 rajveer 1956 
    if result.ex is not None:
1382 varun.gupt 1957 
      raise result.ex
1958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1959 
 
1960 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1961 
    """
1962 
    Returns order ids for orders which can be cancelled
3431 rajveer 1963 
 
1382 varun.gupt 1964 
    Parameters:
1965 
     - customer_id
1966 
     - limit
1967 
    """
1968 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1969 
    return self.recv_getCancellableOrdersForCustomer()
1970 
 
1971 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1972 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1973 
    args = getCancellableOrdersForCustomer_args()
1974 
    args.customer_id = customer_id
1975 
    args.limit = limit
1976 
    args.write(self._oprot)
1977 
    self._oprot.writeMessageEnd()
1978 
    self._oprot.trans.flush()
1979 
 
1980 
  def recv_getCancellableOrdersForCustomer(self, ):
1981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1982 
    if mtype == TMessageType.EXCEPTION:
1983 
      x = TApplicationException()
1984 
      x.read(self._iprot)
1985 
      self._iprot.readMessageEnd()
1986 
      raise x
1987 
    result = getCancellableOrdersForCustomer_result()
1988 
    result.read(self._iprot)
1989 
    self._iprot.readMessageEnd()
3431 rajveer 1990 
    if result.success is not None:
1382 varun.gupt 1991 
      return result.success
3431 rajveer 1992 
    if result.ex is not None:
1382 varun.gupt 1993 
      raise result.ex
1994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1995 
 
483 rajveer 1996 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1997 
    """
1998 
    Parameters:
483 rajveer 1999 
     - orderId
2000 
     - status
2001 
     - description
94 ashish 2002 
    """
483 rajveer 2003 
    self.send_changeOrderStatus(orderId, status, description)
2004 
    return self.recv_changeOrderStatus()
94 ashish 2005 
 
483 rajveer 2006 
  def send_changeOrderStatus(self, orderId, status, description):
2007 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2008 
    args = changeOrderStatus_args()
2009 
    args.orderId = orderId
2010 
    args.status = status
2011 
    args.description = description
94 ashish 2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
483 rajveer 2016 
  def recv_changeOrderStatus(self, ):
94 ashish 2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
483 rajveer 2023 
    result = changeOrderStatus_result()
94 ashish 2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
3431 rajveer 2026 
    if result.success is not None:
94 ashish 2027 
      return result.success
3431 rajveer 2028 
    if result.ex is not None:
94 ashish 2029 
      raise result.ex
483 rajveer 2030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2031 
 
1528 ankur.sing 2032 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2033 
    """
1528 ankur.sing 2034 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2035 
    only user who owns the transaction can view its order details.
3431 rajveer 2036 
 
94 ashish 2037 
    Parameters:
2038 
     - transactionId
1528 ankur.sing 2039 
     - customerId
94 ashish 2040 
    """
1528 ankur.sing 2041 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2042 
    return self.recv_getOrdersForTransaction()
94 ashish 2043 
 
1528 ankur.sing 2044 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2045 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2046 
    args = getOrdersForTransaction_args()
94 ashish 2047 
    args.transactionId = transactionId
1528 ankur.sing 2048 
    args.customerId = customerId
94 ashish 2049 
    args.write(self._oprot)
2050 
    self._oprot.writeMessageEnd()
2051 
    self._oprot.trans.flush()
2052 
 
483 rajveer 2053 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2055 
    if mtype == TMessageType.EXCEPTION:
2056 
      x = TApplicationException()
2057 
      x.read(self._iprot)
2058 
      self._iprot.readMessageEnd()
2059 
      raise x
483 rajveer 2060 
    result = getOrdersForTransaction_result()
94 ashish 2061 
    result.read(self._iprot)
2062 
    self._iprot.readMessageEnd()
3431 rajveer 2063 
    if result.success is not None:
94 ashish 2064 
      return result.success
3431 rajveer 2065 
    if result.ex is not None:
94 ashish 2066 
      raise result.ex
483 rajveer 2067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2068 
 
3014 chandransh 2069 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2070 
    """
3014 chandransh 2071 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2072 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2073 
 
94 ashish 2074 
    Parameters:
483 rajveer 2075 
     - customerId
2076 
     - from_date
2077 
     - to_date
3014 chandransh 2078 
     - statuses
94 ashish 2079 
    """
3014 chandransh 2080 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2081 
    return self.recv_getOrdersForCustomer()
94 ashish 2082 
 
3014 chandransh 2083 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2084 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2085 
    args = getOrdersForCustomer_args()
2086 
    args.customerId = customerId
2087 
    args.from_date = from_date
2088 
    args.to_date = to_date
3014 chandransh 2089 
    args.statuses = statuses
94 ashish 2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
483 rajveer 2094 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
483 rajveer 2101 
    result = getOrdersForCustomer_result()
94 ashish 2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
3431 rajveer 2104 
    if result.success is not None:
94 ashish 2105 
      return result.success
3431 rajveer 2106 
    if result.ex is not None:
94 ashish 2107 
      raise result.ex
483 rajveer 2108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2109 
 
483 rajveer 2110 
  def createOrder(self, order):
94 ashish 2111 
    """
2112 
    Parameters:
483 rajveer 2113 
     - order
94 ashish 2114 
    """
483 rajveer 2115 
    self.send_createOrder(order)
2116 
    return self.recv_createOrder()
94 ashish 2117 
 
483 rajveer 2118 
  def send_createOrder(self, order):
2119 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2120 
    args = createOrder_args()
2121 
    args.order = order
94 ashish 2122 
    args.write(self._oprot)
2123 
    self._oprot.writeMessageEnd()
2124 
    self._oprot.trans.flush()
2125 
 
483 rajveer 2126 
  def recv_createOrder(self, ):
94 ashish 2127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2128 
    if mtype == TMessageType.EXCEPTION:
2129 
      x = TApplicationException()
2130 
      x.read(self._iprot)
2131 
      self._iprot.readMessageEnd()
2132 
      raise x
483 rajveer 2133 
    result = createOrder_result()
94 ashish 2134 
    result.read(self._iprot)
2135 
    self._iprot.readMessageEnd()
3431 rajveer 2136 
    if result.success is not None:
94 ashish 2137 
      return result.success
3431 rajveer 2138 
    if result.ex is not None:
94 ashish 2139 
      raise result.ex
483 rajveer 2140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2141 
 
483 rajveer 2142 
  def getOrder(self, id):
94 ashish 2143 
    """
2144 
    Parameters:
483 rajveer 2145 
     - id
94 ashish 2146 
    """
483 rajveer 2147 
    self.send_getOrder(id)
2148 
    return self.recv_getOrder()
94 ashish 2149 
 
483 rajveer 2150 
  def send_getOrder(self, id):
2151 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2152 
    args = getOrder_args()
2153 
    args.id = id
94 ashish 2154 
    args.write(self._oprot)
2155 
    self._oprot.writeMessageEnd()
2156 
    self._oprot.trans.flush()
2157 
 
483 rajveer 2158 
  def recv_getOrder(self, ):
94 ashish 2159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2160 
    if mtype == TMessageType.EXCEPTION:
2161 
      x = TApplicationException()
2162 
      x.read(self._iprot)
2163 
      self._iprot.readMessageEnd()
2164 
      raise x
483 rajveer 2165 
    result = getOrder_result()
94 ashish 2166 
    result.read(self._iprot)
2167 
    self._iprot.readMessageEnd()
3431 rajveer 2168 
    if result.success is not None:
94 ashish 2169 
      return result.success
3431 rajveer 2170 
    if result.ex is not None:
94 ashish 2171 
      raise result.ex
483 rajveer 2172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2173 
 
483 rajveer 2174 
  def getLineItemsForOrder(self, orderId):
94 ashish 2175 
    """
2176 
    Parameters:
483 rajveer 2177 
     - orderId
94 ashish 2178 
    """
483 rajveer 2179 
    self.send_getLineItemsForOrder(orderId)
2180 
    return self.recv_getLineItemsForOrder()
94 ashish 2181 
 
483 rajveer 2182 
  def send_getLineItemsForOrder(self, orderId):
2183 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2184 
    args = getLineItemsForOrder_args()
2185 
    args.orderId = orderId
94 ashish 2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
483 rajveer 2190 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
483 rajveer 2197 
    result = getLineItemsForOrder_result()
94 ashish 2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
3431 rajveer 2200 
    if result.success is not None:
94 ashish 2201 
      return result.success
3431 rajveer 2202 
    if result.ex is not None:
94 ashish 2203 
      raise result.ex
483 rajveer 2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2205 
 
4999 phani.kuma 2206 
  def getOrderList(self, order_ids):
2207 
    """
2208 
    Parameters:
2209 
     - order_ids
2210 
    """
2211 
    self.send_getOrderList(order_ids)
2212 
    return self.recv_getOrderList()
2213 
 
2214 
  def send_getOrderList(self, order_ids):
2215 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2216 
    args = getOrderList_args()
2217 
    args.order_ids = order_ids
2218 
    args.write(self._oprot)
2219 
    self._oprot.writeMessageEnd()
2220 
    self._oprot.trans.flush()
2221 
 
2222 
  def recv_getOrderList(self, ):
2223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2224 
    if mtype == TMessageType.EXCEPTION:
2225 
      x = TApplicationException()
2226 
      x.read(self._iprot)
2227 
      self._iprot.readMessageEnd()
2228 
      raise x
2229 
    result = getOrderList_result()
2230 
    result.read(self._iprot)
2231 
    self._iprot.readMessageEnd()
2232 
    if result.success is not None:
2233 
      return result.success
2234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2235 
 
5386 phani.kuma 2236 
  def getOrderListForVendor(self, order_ids, vendorId):
2237 
    """
2238 
    Parameters:
2239 
     - order_ids
2240 
     - vendorId
2241 
    """
2242 
    self.send_getOrderListForVendor(order_ids, vendorId)
2243 
    return self.recv_getOrderListForVendor()
2244 
 
2245 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2246 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2247 
    args = getOrderListForVendor_args()
2248 
    args.order_ids = order_ids
2249 
    args.vendorId = vendorId
2250 
    args.write(self._oprot)
2251 
    self._oprot.writeMessageEnd()
2252 
    self._oprot.trans.flush()
2253 
 
2254 
  def recv_getOrderListForVendor(self, ):
2255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2256 
    if mtype == TMessageType.EXCEPTION:
2257 
      x = TApplicationException()
2258 
      x.read(self._iprot)
2259 
      self._iprot.readMessageEnd()
2260 
      raise x
2261 
    result = getOrderListForVendor_result()
2262 
    result.read(self._iprot)
2263 
    self._iprot.readMessageEnd()
2264 
    if result.success is not None:
2265 
      return result.success
2266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2267 
 
1528 ankur.sing 2268 
  def getOrderForCustomer(self, orderId, customerId):
2269 
    """
2270 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2271 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2272 
 
1528 ankur.sing 2273 
    Parameters:
2274 
     - orderId
2275 
     - customerId
2276 
    """
2277 
    self.send_getOrderForCustomer(orderId, customerId)
2278 
    return self.recv_getOrderForCustomer()
2279 
 
2280 
  def send_getOrderForCustomer(self, orderId, customerId):
2281 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2282 
    args = getOrderForCustomer_args()
2283 
    args.orderId = orderId
2284 
    args.customerId = customerId
2285 
    args.write(self._oprot)
2286 
    self._oprot.writeMessageEnd()
2287 
    self._oprot.trans.flush()
2288 
 
2289 
  def recv_getOrderForCustomer(self, ):
2290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2291 
    if mtype == TMessageType.EXCEPTION:
2292 
      x = TApplicationException()
2293 
      x.read(self._iprot)
2294 
      self._iprot.readMessageEnd()
2295 
      raise x
2296 
    result = getOrderForCustomer_result()
2297 
    result.read(self._iprot)
2298 
    self._iprot.readMessageEnd()
3431 rajveer 2299 
    if result.success is not None:
1528 ankur.sing 2300 
      return result.success
3431 rajveer 2301 
    if result.ex is not None:
1528 ankur.sing 2302 
      raise result.ex
2303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2304 
 
4444 rajveer 2305 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2306 
    """
2307 
    Parameters:
4394 rajveer 2308 
     - type
4444 rajveer 2309 
     - warehouseId
4394 rajveer 2310 
     - status
2311 
     - timestamp
3064 chandransh 2312 
    """
4444 rajveer 2313 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2314 
    return self.recv_getAlerts()
2315 
 
4444 rajveer 2316 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2317 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2318 
    args = getAlerts_args()
4394 rajveer 2319 
    args.type = type
4444 rajveer 2320 
    args.warehouseId = warehouseId
4394 rajveer 2321 
    args.status = status
2322 
    args.timestamp = timestamp
3064 chandransh 2323 
    args.write(self._oprot)
2324 
    self._oprot.writeMessageEnd()
2325 
    self._oprot.trans.flush()
2326 
 
2327 
  def recv_getAlerts(self, ):
2328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2329 
    if mtype == TMessageType.EXCEPTION:
2330 
      x = TApplicationException()
2331 
      x.read(self._iprot)
2332 
      self._iprot.readMessageEnd()
2333 
      raise x
2334 
    result = getAlerts_result()
2335 
    result.read(self._iprot)
2336 
    self._iprot.readMessageEnd()
3431 rajveer 2337 
    if result.success is not None:
3064 chandransh 2338 
      return result.success
2339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2340 
 
4444 rajveer 2341 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2342 
    """
2343 
    Parameters:
2344 
     - type
4444 rajveer 2345 
     - warehouseId
4394 rajveer 2346 
     - description
3064 chandransh 2347 
    """
4444 rajveer 2348 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2349 
    self.recv_addAlert()
3064 chandransh 2350 
 
4444 rajveer 2351 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2352 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2353 
    args = addAlert_args()
3064 chandransh 2354 
    args.type = type
4444 rajveer 2355 
    args.warehouseId = warehouseId
4394 rajveer 2356 
    args.description = description
3064 chandransh 2357 
    args.write(self._oprot)
2358 
    self._oprot.writeMessageEnd()
2359 
    self._oprot.trans.flush()
2360 
 
4394 rajveer 2361 
  def recv_addAlert(self, ):
3064 chandransh 2362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2363 
    if mtype == TMessageType.EXCEPTION:
2364 
      x = TApplicationException()
2365 
      x.read(self._iprot)
2366 
      self._iprot.readMessageEnd()
2367 
      raise x
4394 rajveer 2368 
    result = addAlert_result()
3064 chandransh 2369 
    result.read(self._iprot)
2370 
    self._iprot.readMessageEnd()
2371 
    return
2372 
 
4444 rajveer 2373 
  def markAlertsAsSeen(self, warehouseId):
2374 
    """
2375 
    Parameters:
2376 
     - warehouseId
2377 
    """
2378 
    self.send_markAlertsAsSeen(warehouseId)
2379 
    self.recv_markAlertsAsSeen()
2380 
 
2381 
  def send_markAlertsAsSeen(self, warehouseId):
2382 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2383 
    args = markAlertsAsSeen_args()
2384 
    args.warehouseId = warehouseId
2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
2389 
  def recv_markAlertsAsSeen(self, ):
2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
2396 
    result = markAlertsAsSeen_result()
2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
2399 
    return
2400 
 
3064 chandransh 2401 
  def getValidOrderCount(self, ):
2402 
    """
2403 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2404 
    """
2405 
    self.send_getValidOrderCount()
2406 
    return self.recv_getValidOrderCount()
2407 
 
2408 
  def send_getValidOrderCount(self, ):
2409 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2410 
    args = getValidOrderCount_args()
2411 
    args.write(self._oprot)
2412 
    self._oprot.writeMessageEnd()
2413 
    self._oprot.trans.flush()
2414 
 
2415 
  def recv_getValidOrderCount(self, ):
2416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2417 
    if mtype == TMessageType.EXCEPTION:
2418 
      x = TApplicationException()
2419 
      x.read(self._iprot)
2420 
      self._iprot.readMessageEnd()
2421 
      raise x
2422 
    result = getValidOrderCount_result()
2423 
    result.read(self._iprot)
2424 
    self._iprot.readMessageEnd()
3431 rajveer 2425 
    if result.success is not None:
3064 chandransh 2426 
      return result.success
2427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2428 
 
2429 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2430 
    """
2431 
    Returns the number of distinct customers who have done successful transactions
2432 
    """
2433 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2434 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2435 
 
2436 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2437 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2438 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2439 
    args.write(self._oprot)
2440 
    self._oprot.writeMessageEnd()
2441 
    self._oprot.trans.flush()
2442 
 
2443 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2445 
    if mtype == TMessageType.EXCEPTION:
2446 
      x = TApplicationException()
2447 
      x.read(self._iprot)
2448 
      self._iprot.readMessageEnd()
2449 
      raise x
2450 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2451 
    result.read(self._iprot)
2452 
    self._iprot.readMessageEnd()
3431 rajveer 2453 
    if result.success is not None:
3064 chandransh 2454 
      return result.success
2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2456 
 
2457 
  def getValidOrdersAmountRange(self, ):
2458 
    """
2459 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2460 
    List contains two values, first minimum amount and second maximum amount.
2461 
    """
2462 
    self.send_getValidOrdersAmountRange()
2463 
    return self.recv_getValidOrdersAmountRange()
2464 
 
2465 
  def send_getValidOrdersAmountRange(self, ):
2466 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2467 
    args = getValidOrdersAmountRange_args()
2468 
    args.write(self._oprot)
2469 
    self._oprot.writeMessageEnd()
2470 
    self._oprot.trans.flush()
2471 
 
2472 
  def recv_getValidOrdersAmountRange(self, ):
2473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2474 
    if mtype == TMessageType.EXCEPTION:
2475 
      x = TApplicationException()
2476 
      x.read(self._iprot)
2477 
      self._iprot.readMessageEnd()
2478 
      raise x
2479 
    result = getValidOrdersAmountRange_result()
2480 
    result.read(self._iprot)
2481 
    self._iprot.readMessageEnd()
3431 rajveer 2482 
    if result.success is not None:
3064 chandransh 2483 
      return result.success
2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2485 
 
5874 rajveer 2486 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2487 
    """
2488 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2489 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2490 
 
3064 chandransh 2491 
    Parameters:
2492 
     - limit
5874 rajveer 2493 
     - onlyStore
3064 chandransh 2494 
    """
5874 rajveer 2495 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2496 
    return self.recv_getValidOrders()
2497 
 
5874 rajveer 2498 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2499 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2500 
    args = getValidOrders_args()
2501 
    args.limit = limit
5874 rajveer 2502 
    args.onlyStore = onlyStore
3064 chandransh 2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_getValidOrders(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = getValidOrders_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
3431 rajveer 2517 
    if result.success is not None:
3064 chandransh 2518 
      return result.success
2519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2520 
 
1220 chandransh 2521 
  def batchOrders(self, warehouseId):
2522 
    """
2523 
    Create a batch of all the pending orders for the given warehouse.
2524 
    The returned list is orderd by created_timestamp.
2525 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2526 
 
1220 chandransh 2527 
    Parameters:
2528 
     - warehouseId
2529 
    """
2530 
    self.send_batchOrders(warehouseId)
2531 
    return self.recv_batchOrders()
2532 
 
2533 
  def send_batchOrders(self, warehouseId):
2534 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2535 
    args = batchOrders_args()
2536 
    args.warehouseId = warehouseId
2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
2541 
  def recv_batchOrders(self, ):
2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
2548 
    result = batchOrders_result()
2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
3431 rajveer 2551 
    if result.success is not None:
1220 chandransh 2552 
      return result.success
3431 rajveer 2553 
    if result.ex is not None:
1220 chandransh 2554 
      raise result.ex
2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2556 
 
1208 chandransh 2557 
  def markOrderAsOutOfStock(self, orderId):
2558 
    """
2559 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2560 
 
1208 chandransh 2561 
    Parameters:
2562 
     - orderId
2563 
    """
2564 
    self.send_markOrderAsOutOfStock(orderId)
2565 
    return self.recv_markOrderAsOutOfStock()
2566 
 
2567 
  def send_markOrderAsOutOfStock(self, orderId):
2568 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2569 
    args = markOrderAsOutOfStock_args()
2570 
    args.orderId = orderId
2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2575 
  def recv_markOrderAsOutOfStock(self, ):
2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2582 
    result = markOrderAsOutOfStock_result()
2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
3431 rajveer 2585 
    if result.success is not None:
1208 chandransh 2586 
      return result.success
3431 rajveer 2587 
    if result.ex is not None:
1208 chandransh 2588 
      raise result.ex
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2590 
 
3064 chandransh 2591 
  def verifyOrder(self, orderId):
759 chandransh 2592 
    """
3064 chandransh 2593 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2594 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2595 
    used for all other orders as well.
2596 
    Throws an exception if no such order exists.
3431 rajveer 2597 
 
759 chandransh 2598 
    Parameters:
3064 chandransh 2599 
     - orderId
759 chandransh 2600 
    """
3064 chandransh 2601 
    self.send_verifyOrder(orderId)
2602 
    return self.recv_verifyOrder()
759 chandransh 2603 
 
3064 chandransh 2604 
  def send_verifyOrder(self, orderId):
2605 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2606 
    args = verifyOrder_args()
2607 
    args.orderId = orderId
759 chandransh 2608 
    args.write(self._oprot)
2609 
    self._oprot.writeMessageEnd()
2610 
    self._oprot.trans.flush()
2611 
 
3064 chandransh 2612 
  def recv_verifyOrder(self, ):
759 chandransh 2613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2614 
    if mtype == TMessageType.EXCEPTION:
2615 
      x = TApplicationException()
2616 
      x.read(self._iprot)
2617 
      self._iprot.readMessageEnd()
2618 
      raise x
3064 chandransh 2619 
    result = verifyOrder_result()
759 chandransh 2620 
    result.read(self._iprot)
2621 
    self._iprot.readMessageEnd()
3431 rajveer 2622 
    if result.success is not None:
759 chandransh 2623 
      return result.success
3431 rajveer 2624 
    if result.ex is not None:
759 chandransh 2625 
      raise result.ex
3064 chandransh 2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2627 
 
3064 chandransh 2628 
  def acceptOrder(self, orderId):
1113 chandransh 2629 
    """
3064 chandransh 2630 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2631 
    given order is not a COD order, it also captures the payment if the same has
2632 
    not been captured.
2633 
    Throws an exception if no such order exists.
3431 rajveer 2634 
 
1113 chandransh 2635 
    Parameters:
3064 chandransh 2636 
     - orderId
1113 chandransh 2637 
    """
3064 chandransh 2638 
    self.send_acceptOrder(orderId)
2639 
    return self.recv_acceptOrder()
1113 chandransh 2640 
 
3064 chandransh 2641 
  def send_acceptOrder(self, orderId):
2642 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2643 
    args = acceptOrder_args()
2644 
    args.orderId = orderId
1113 chandransh 2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
3064 chandransh 2649 
  def recv_acceptOrder(self, ):
1113 chandransh 2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
3064 chandransh 2656 
    result = acceptOrder_result()
1113 chandransh 2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
3431 rajveer 2659 
    if result.success is not None:
1113 chandransh 2660 
      return result.success
3431 rajveer 2661 
    if result.ex is not None:
1113 chandransh 2662 
      raise result.ex
3064 chandransh 2663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2664 
 
5110 mandeep.dh 2665 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2666 
    """
3064 chandransh 2667 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2668 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2669 
    the IMEI no. if a -1 is supplied.
2670 
    Also, it generates an invoice number for the order, marks the order as
2671 
    BILLED and sets the billing timestamp.
2672 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2673 
 
1135 chandransh 2674 
    Parameters:
3064 chandransh 2675 
     - orderId
2676 
     - invoice_number
4658 mandeep.dh 2677 
     - serialNumber
4283 anupam.sin 2678 
     - itemNumber
3064 chandransh 2679 
     - billed_by
4264 rajveer 2680 
     - jacketNumber
4283 anupam.sin 2681 
     - billingType
5110 mandeep.dh 2682 
     - fulfilmentWarehouseId
4763 rajveer 2683 
     - authorize
1135 chandransh 2684 
    """
5110 mandeep.dh 2685 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2686 
    return self.recv_addBillingDetails()
1135 chandransh 2687 
 
5110 mandeep.dh 2688 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2689 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2690 
    args = addBillingDetails_args()
2691 
    args.orderId = orderId
2692 
    args.invoice_number = invoice_number
4658 mandeep.dh 2693 
    args.serialNumber = serialNumber
4283 anupam.sin 2694 
    args.itemNumber = itemNumber
3064 chandransh 2695 
    args.billed_by = billed_by
4264 rajveer 2696 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2697 
    args.billingType = billingType
5110 mandeep.dh 2698 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2699 
    args.authorize = authorize
1135 chandransh 2700 
    args.write(self._oprot)
2701 
    self._oprot.writeMessageEnd()
2702 
    self._oprot.trans.flush()
2703 
 
3064 chandransh 2704 
  def recv_addBillingDetails(self, ):
1135 chandransh 2705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2706 
    if mtype == TMessageType.EXCEPTION:
2707 
      x = TApplicationException()
2708 
      x.read(self._iprot)
2709 
      self._iprot.readMessageEnd()
2710 
      raise x
3064 chandransh 2711 
    result = addBillingDetails_result()
1135 chandransh 2712 
    result.read(self._iprot)
2713 
    self._iprot.readMessageEnd()
3431 rajveer 2714 
    if result.success is not None:
3064 chandransh 2715 
      return result.success
3431 rajveer 2716 
    if result.ex is not None:
1135 chandransh 2717 
      raise result.ex
3064 chandransh 2718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2719 
 
6756 amar.kumar 2720 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2721 
    """
2722 
    Add the invoice number to the order.
2723 
 
2724 
    Parameters:
2725 
     - orderId
2726 
     - invoiceNumber
4763 rajveer 2727 
     - color
6756 amar.kumar 2728 
     - serialNumber
2729 
     - itemNumber
4579 rajveer 2730 
    """
6756 amar.kumar 2731 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2732 
    self.recv_addInvoiceNumber()
2733 
 
6756 amar.kumar 2734 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2735 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2736 
    args = addInvoiceNumber_args()
2737 
    args.orderId = orderId
2738 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2739 
    args.color = color
6756 amar.kumar 2740 
    args.serialNumber = serialNumber
2741 
    args.itemNumber = itemNumber
4579 rajveer 2742 
    args.write(self._oprot)
2743 
    self._oprot.writeMessageEnd()
2744 
    self._oprot.trans.flush()
2745 
 
2746 
  def recv_addInvoiceNumber(self, ):
2747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2748 
    if mtype == TMessageType.EXCEPTION:
2749 
      x = TApplicationException()
2750 
      x.read(self._iprot)
2751 
      self._iprot.readMessageEnd()
2752 
      raise x
2753 
    result = addInvoiceNumber_result()
2754 
    result.read(self._iprot)
2755 
    self._iprot.readMessageEnd()
2756 
    if result.ex is not None:
2757 
      raise result.ex
2758 
    return
2759 
 
4910 phani.kuma 2760 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2761 
    """
3064 chandransh 2762 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2763 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2764 
 
1408 ankur.sing 2765 
    Parameters:
3064 chandransh 2766 
     - warehouseId
1408 ankur.sing 2767 
     - providerId
3064 chandransh 2768 
     - cod
4910 phani.kuma 2769 
     - orderIds
1408 ankur.sing 2770 
    """
4910 phani.kuma 2771 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2772 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2773 
 
4910 phani.kuma 2774 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2775 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2776 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2777 
    args.warehouseId = warehouseId
1408 ankur.sing 2778 
    args.providerId = providerId
3064 chandransh 2779 
    args.cod = cod
4910 phani.kuma 2780 
    args.orderIds = orderIds
1408 ankur.sing 2781 
    args.write(self._oprot)
2782 
    self._oprot.writeMessageEnd()
2783 
    self._oprot.trans.flush()
2784 
 
4910 phani.kuma 2785 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2787 
    if mtype == TMessageType.EXCEPTION:
2788 
      x = TApplicationException()
2789 
      x.read(self._iprot)
2790 
      self._iprot.readMessageEnd()
2791 
      raise x
4910 phani.kuma 2792 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2793 
    result.read(self._iprot)
2794 
    self._iprot.readMessageEnd()
3431 rajveer 2795 
    if result.success is not None:
1408 ankur.sing 2796 
      return result.success
3431 rajveer 2797 
    if result.ex is not None:
3064 chandransh 2798 
      raise result.ex
4910 phani.kuma 2799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2800 
 
5713 rajveer 2801 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2802 
    """
2803 
    Parameters:
2804 
     - providerId
2805 
     - orderIds
5713 rajveer 2806 
     - awbs
5676 rajveer 2807 
    """
5713 rajveer 2808 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2809 
    return self.recv_markOrdersAsReturnedFromStore()
2810 
 
5713 rajveer 2811 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2812 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2813 
    args = markOrdersAsReturnedFromStore_args()
2814 
    args.providerId = providerId
2815 
    args.orderIds = orderIds
5713 rajveer 2816 
    args.awbs = awbs
5676 rajveer 2817 
    args.write(self._oprot)
2818 
    self._oprot.writeMessageEnd()
2819 
    self._oprot.trans.flush()
2820 
 
2821 
  def recv_markOrdersAsReturnedFromStore(self, ):
2822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2823 
    if mtype == TMessageType.EXCEPTION:
2824 
      x = TApplicationException()
2825 
      x.read(self._iprot)
2826 
      self._iprot.readMessageEnd()
2827 
      raise x
2828 
    result = markOrdersAsReturnedFromStore_result()
2829 
    result.read(self._iprot)
2830 
    self._iprot.readMessageEnd()
2831 
    if result.success is not None:
2832 
      return result.success
2833 
    if result.ex is not None:
2834 
      raise result.ex
2835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2836 
 
4910 phani.kuma 2837 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2838 
    """
4910 phani.kuma 2839 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2840 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2841 
 
2842 
    Parameters:
2843 
     - providerId
4910 phani.kuma 2844 
     - pickupDetails
4410 rajveer 2845 
    """
4910 phani.kuma 2846 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2847 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2848 
 
4910 phani.kuma 2849 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2850 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2851 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2852 
    args.providerId = providerId
4910 phani.kuma 2853 
    args.pickupDetails = pickupDetails
4410 rajveer 2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
4910 phani.kuma 2858 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
4910 phani.kuma 2865 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
2868 
    if result.ex is not None:
2869 
      raise result.ex
4910 phani.kuma 2870 
    return
4410 rajveer 2871 
 
4910 phani.kuma 2872 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2873 
    """
3064 chandransh 2874 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2875 
 
94 ashish 2876 
    Parameters:
3064 chandransh 2877 
     - providerId
304 ashish 2878 
    """
4910 phani.kuma 2879 
    self.send_getOrdersNotPickedUp(providerId)
2880 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2881 
 
4910 phani.kuma 2882 
  def send_getOrdersNotPickedUp(self, providerId):
2883 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2884 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2885 
    args.providerId = providerId
304 ashish 2886 
    args.write(self._oprot)
2887 
    self._oprot.writeMessageEnd()
2888 
    self._oprot.trans.flush()
2889 
 
4910 phani.kuma 2890 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2892 
    if mtype == TMessageType.EXCEPTION:
2893 
      x = TApplicationException()
2894 
      x.read(self._iprot)
2895 
      self._iprot.readMessageEnd()
2896 
      raise x
4910 phani.kuma 2897 
    result = getOrdersNotPickedUp_result()
304 ashish 2898 
    result.read(self._iprot)
2899 
    self._iprot.readMessageEnd()
3431 rajveer 2900 
    if result.success is not None:
304 ashish 2901 
      return result.success
4910 phani.kuma 2902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2903 
 
3064 chandransh 2904 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2905 
    """
3064 chandransh 2906 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2907 
    the name of the receiver.
2908 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2909 
 
304 ashish 2910 
    Parameters:
3064 chandransh 2911 
     - providerId
2912 
     - deliveredOrders
304 ashish 2913 
    """
3064 chandransh 2914 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2915 
    self.recv_markOrdersAsDelivered()
304 ashish 2916 
 
3064 chandransh 2917 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2918 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2919 
    args = markOrdersAsDelivered_args()
2920 
    args.providerId = providerId
2921 
    args.deliveredOrders = deliveredOrders
304 ashish 2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
3064 chandransh 2926 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
3064 chandransh 2933 
    result = markOrdersAsDelivered_result()
304 ashish 2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
3431 rajveer 2936 
    if result.ex is not None:
3064 chandransh 2937 
      raise result.ex
304 ashish 2938 
    return
2939 
 
4910 phani.kuma 2940 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2941 
    """
4910 phani.kuma 2942 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2943 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2944 
 
3064 chandransh 2945 
    Parameters:
2946 
     - providerId
2947 
     - returnedOrders
1596 ankur.sing 2948 
    """
4910 phani.kuma 2949 
    self.send_markAsRTOrders(providerId, returnedOrders)
2950 
    self.recv_markAsRTOrders()
304 ashish 2951 
 
4910 phani.kuma 2952 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2953 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2954 
    args = markAsRTOrders_args()
3064 chandransh 2955 
    args.providerId = providerId
2956 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2957 
    args.write(self._oprot)
2958 
    self._oprot.writeMessageEnd()
2959 
    self._oprot.trans.flush()
2960 
 
4910 phani.kuma 2961 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2963 
    if mtype == TMessageType.EXCEPTION:
2964 
      x = TApplicationException()
2965 
      x.read(self._iprot)
2966 
      self._iprot.readMessageEnd()
2967 
      raise x
4910 phani.kuma 2968 
    result = markAsRTOrders_result()
1596 ankur.sing 2969 
    result.read(self._iprot)
2970 
    self._iprot.readMessageEnd()
3431 rajveer 2971 
    if result.ex is not None:
3064 chandransh 2972 
      raise result.ex
2973 
    return
1596 ankur.sing 2974 
 
4910 phani.kuma 2975 
  def getRTOrders(self, providerId):
2976 
    """
2977 
    Returns a list of orders that were returned by courier.
2978 
 
2979 
    Parameters:
2980 
     - providerId
2981 
    """
2982 
    self.send_getRTOrders(providerId)
2983 
    return self.recv_getRTOrders()
2984 
 
2985 
  def send_getRTOrders(self, providerId):
2986 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2987 
    args = getRTOrders_args()
2988 
    args.providerId = providerId
2989 
    args.write(self._oprot)
2990 
    self._oprot.writeMessageEnd()
2991 
    self._oprot.trans.flush()
2992 
 
2993 
  def recv_getRTOrders(self, ):
2994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2995 
    if mtype == TMessageType.EXCEPTION:
2996 
      x = TApplicationException()
2997 
      x.read(self._iprot)
2998 
      self._iprot.readMessageEnd()
2999 
      raise x
3000 
    result = getRTOrders_result()
3001 
    result.read(self._iprot)
3002 
    self._iprot.readMessageEnd()
3003 
    if result.success is not None:
3004 
      return result.success
3005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3006 
 
3064 chandransh 3007 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3008 
    """
3064 chandransh 3009 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3010 
 
3064 chandransh 3011 
    Parameters:
3012 
     - providerId
3013 
     - undeliveredOrders
1627 ankur.sing 3014 
    """
3064 chandransh 3015 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3016 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3017 
 
3064 chandransh 3018 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3019 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3020 
    args = updateNonDeliveryReason_args()
3021 
    args.providerId = providerId
3022 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3023 
    args.write(self._oprot)
3024 
    self._oprot.writeMessageEnd()
3025 
    self._oprot.trans.flush()
3026 
 
3064 chandransh 3027 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3029 
    if mtype == TMessageType.EXCEPTION:
3030 
      x = TApplicationException()
3031 
      x.read(self._iprot)
3032 
      self._iprot.readMessageEnd()
3033 
      raise x
3064 chandransh 3034 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3035 
    result.read(self._iprot)
3036 
    self._iprot.readMessageEnd()
4910 phani.kuma 3037 
    if result.ex is not None:
3038 
      raise result.ex
3039 
    return
3040 
 
3041 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3042 
    """
3043 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3044 
 
3045 
    Parameters:
3046 
     - providerId
3047 
    """
3048 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3049 
    return self.recv_getNonDeliveredOrdersbyCourier()
3050 
 
3051 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3052 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3053 
    args = getNonDeliveredOrdersbyCourier_args()
3054 
    args.providerId = providerId
3055 
    args.write(self._oprot)
3056 
    self._oprot.writeMessageEnd()
3057 
    self._oprot.trans.flush()
3058 
 
3059 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3061 
    if mtype == TMessageType.EXCEPTION:
3062 
      x = TApplicationException()
3063 
      x.read(self._iprot)
3064 
      self._iprot.readMessageEnd()
3065 
      raise x
3066 
    result = getNonDeliveredOrdersbyCourier_result()
3067 
    result.read(self._iprot)
3068 
    self._iprot.readMessageEnd()
4581 phani.kuma 3069 
    if result.success is not None:
3070 
      return result.success
4910 phani.kuma 3071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3072 
 
3073 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3074 
    """
3075 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3076 
 
3077 
    Parameters:
3078 
     - providerId
3079 
     - local_connected_orders
3080 
    """
3081 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3082 
    self.recv_markOrdersAsLocalConnected()
3083 
 
3084 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3085 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3086 
    args = markOrdersAsLocalConnected_args()
3087 
    args.providerId = providerId
3088 
    args.local_connected_orders = local_connected_orders
3089 
    args.write(self._oprot)
3090 
    self._oprot.writeMessageEnd()
3091 
    self._oprot.trans.flush()
3092 
 
3093 
  def recv_markOrdersAsLocalConnected(self, ):
3094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3095 
    if mtype == TMessageType.EXCEPTION:
3096 
      x = TApplicationException()
3097 
      x.read(self._iprot)
3098 
      self._iprot.readMessageEnd()
3099 
      raise x
3100 
    result = markOrdersAsLocalConnected_result()
3101 
    result.read(self._iprot)
3102 
    self._iprot.readMessageEnd()
3431 rajveer 3103 
    if result.ex is not None:
3064 chandransh 3104 
      raise result.ex
4910 phani.kuma 3105 
    return
1627 ankur.sing 3106 
 
4910 phani.kuma 3107 
  def getOrdersNotLocalConnected(self, providerId):
3108 
    """
3109 
    Returns a list of orders that were picked up or shipped but pending local connection.
3110 
 
3111 
    Parameters:
3112 
     - providerId
3113 
    """
3114 
    self.send_getOrdersNotLocalConnected(providerId)
3115 
    return self.recv_getOrdersNotLocalConnected()
3116 
 
3117 
  def send_getOrdersNotLocalConnected(self, providerId):
3118 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3119 
    args = getOrdersNotLocalConnected_args()
3120 
    args.providerId = providerId
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_getOrdersNotLocalConnected(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = getOrdersNotLocalConnected_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3135 
    if result.success is not None:
3136 
      return result.success
3137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3138 
 
3139 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3140 
    """
3141 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3142 
 
3143 
    Parameters:
3144 
     - providerId
3145 
     - destination_city_reached_orders
3146 
    """
3147 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3148 
    self.recv_markOrdersAsDestinationCityReached()
3149 
 
3150 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3151 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3152 
    args = markOrdersAsDestinationCityReached_args()
3153 
    args.providerId = providerId
3154 
    args.destination_city_reached_orders = destination_city_reached_orders
3155 
    args.write(self._oprot)
3156 
    self._oprot.writeMessageEnd()
3157 
    self._oprot.trans.flush()
3158 
 
3159 
  def recv_markOrdersAsDestinationCityReached(self, ):
3160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3161 
    if mtype == TMessageType.EXCEPTION:
3162 
      x = TApplicationException()
3163 
      x.read(self._iprot)
3164 
      self._iprot.readMessageEnd()
3165 
      raise x
3166 
    result = markOrdersAsDestinationCityReached_result()
3167 
    result.read(self._iprot)
3168 
    self._iprot.readMessageEnd()
3169 
    if result.ex is not None:
3170 
      raise result.ex
3171 
    return
3172 
 
3173 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3174 
    """
3175 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3176 
 
3177 
    Parameters:
3178 
     - providerId
3179 
     - first_atdl_orders
3180 
    """
3181 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3182 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3183 
 
3184 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3185 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3186 
    args = markOrdersAsFirstDeliveryAttempted_args()
3187 
    args.providerId = providerId
3188 
    args.first_atdl_orders = first_atdl_orders
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = markOrdersAsFirstDeliveryAttempted_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
3203 
    if result.ex is not None:
3204 
      raise result.ex
3205 
    return
3206 
 
3064 chandransh 3207 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3208 
    """
3064 chandransh 3209 
    Returns the list of orders whose delivery time has passed but have not been
3210 
    delivered yet for the given provider and warehouse. To get a complete list of
3211 
    undelivered orders, pass them as -1.
3212 
    Returns an empty list if no such orders exist.
3431 rajveer 3213 
 
1886 ankur.sing 3214 
    Parameters:
3064 chandransh 3215 
     - providerId
3216 
     - warehouseId
1886 ankur.sing 3217 
    """
3064 chandransh 3218 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3219 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3220 
 
3064 chandransh 3221 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3222 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3223 
    args = getUndeliveredOrders_args()
3224 
    args.providerId = providerId
3225 
    args.warehouseId = warehouseId
1886 ankur.sing 3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3064 chandransh 3230 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3064 chandransh 3237 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3431 rajveer 3240 
    if result.success is not None:
1886 ankur.sing 3241 
      return result.success
3064 chandransh 3242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3243 
 
4783 phani.kuma 3244 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3245 
    """
3246 
    Returns the list of orders whose expected delivery date has passed but have not been
3247 
    delivered yet.
3248 
    Returns an empty list if no such orders exist.
3249 
    """
3250 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3251 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3252 
 
3253 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3254 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3255 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3256 
    args.write(self._oprot)
3257 
    self._oprot.writeMessageEnd()
3258 
    self._oprot.trans.flush()
3259 
 
3260 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3262 
    if mtype == TMessageType.EXCEPTION:
3263 
      x = TApplicationException()
3264 
      x.read(self._iprot)
3265 
      self._iprot.readMessageEnd()
3266 
      raise x
3267 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3268 
    result.read(self._iprot)
3269 
    self._iprot.readMessageEnd()
3270 
    if result.success is not None:
3271 
      return result.success
3272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3273 
 
2536 chandransh 3274 
  def toggleDOAFlag(self, orderId):
3275 
    """
3276 
    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.
3277 
    Returns the final flag status.
3278 
    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 3279 
 
2536 chandransh 3280 
    Parameters:
3281 
     - orderId
3282 
    """
3283 
    self.send_toggleDOAFlag(orderId)
3284 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3285 
 
2536 chandransh 3286 
  def send_toggleDOAFlag(self, orderId):
3287 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3288 
    args = toggleDOAFlag_args()
3289 
    args.orderId = orderId
3290 
    args.write(self._oprot)
3291 
    self._oprot.writeMessageEnd()
3292 
    self._oprot.trans.flush()
3293 
 
3294 
  def recv_toggleDOAFlag(self, ):
3295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3296 
    if mtype == TMessageType.EXCEPTION:
3297 
      x = TApplicationException()
3298 
      x.read(self._iprot)
3299 
      self._iprot.readMessageEnd()
3300 
      raise x
3301 
    result = toggleDOAFlag_result()
3302 
    result.read(self._iprot)
3303 
    self._iprot.readMessageEnd()
3431 rajveer 3304 
    if result.success is not None:
2536 chandransh 3305 
      return result.success
3431 rajveer 3306 
    if result.ex is not None:
2536 chandransh 3307 
      raise result.ex
3308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3309 
 
4712 rajveer 3310 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3311 
    """
3312 
    Parameters:
3313 
     - orderId
3314 
     - deliveryTimestamp
3315 
     - receiver
3316 
    """
3317 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3318 
    self.recv_markOrderAsDelivered()
3319 
 
3320 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3321 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3322 
    args = markOrderAsDelivered_args()
3323 
    args.orderId = orderId
3324 
    args.deliveryTimestamp = deliveryTimestamp
3325 
    args.receiver = receiver
3326 
    args.write(self._oprot)
3327 
    self._oprot.writeMessageEnd()
3328 
    self._oprot.trans.flush()
3329 
 
3330 
  def recv_markOrderAsDelivered(self, ):
3331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3332 
    if mtype == TMessageType.EXCEPTION:
3333 
      x = TApplicationException()
3334 
      x.read(self._iprot)
3335 
      self._iprot.readMessageEnd()
3336 
      raise x
3337 
    result = markOrderAsDelivered_result()
3338 
    result.read(self._iprot)
3339 
    self._iprot.readMessageEnd()
3340 
    if result.ex is not None:
3341 
      raise result.ex
3342 
    return
3343 
 
5553 rajveer 3344 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3345 
    """
3346 
    Parameters:
3347 
     - orderId
3348 
     - deliveryTimestamp
3349 
    """
3350 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3351 
    self.recv_markOrderAsReceivedAtStore()
3352 
 
3353 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3354 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3355 
    args = markOrderAsReceivedAtStore_args()
3356 
    args.orderId = orderId
3357 
    args.deliveryTimestamp = deliveryTimestamp
3358 
    args.write(self._oprot)
3359 
    self._oprot.writeMessageEnd()
3360 
    self._oprot.trans.flush()
3361 
 
3362 
  def recv_markOrderAsReceivedAtStore(self, ):
3363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3364 
    if mtype == TMessageType.EXCEPTION:
3365 
      x = TApplicationException()
3366 
      x.read(self._iprot)
3367 
      self._iprot.readMessageEnd()
3368 
      raise x
3369 
    result = markOrderAsReceivedAtStore_result()
3370 
    result.read(self._iprot)
3371 
    self._iprot.readMessageEnd()
3372 
    if result.ex is not None:
3373 
      raise result.ex
3374 
    return
3375 
 
4454 rajveer 3376 
  def markOrderDoaRequestReceived(self, orderId):
3377 
    """
3378 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3379 
 
3380 
    Parameters:
3381 
     - orderId
3382 
    """
3383 
    self.send_markOrderDoaRequestReceived(orderId)
3384 
    return self.recv_markOrderDoaRequestReceived()
3385 
 
3386 
  def send_markOrderDoaRequestReceived(self, orderId):
3387 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3388 
    args = markOrderDoaRequestReceived_args()
3389 
    args.orderId = orderId
3390 
    args.write(self._oprot)
3391 
    self._oprot.writeMessageEnd()
3392 
    self._oprot.trans.flush()
3393 
 
3394 
  def recv_markOrderDoaRequestReceived(self, ):
3395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3396 
    if mtype == TMessageType.EXCEPTION:
3397 
      x = TApplicationException()
3398 
      x.read(self._iprot)
3399 
      self._iprot.readMessageEnd()
3400 
      raise x
3401 
    result = markOrderDoaRequestReceived_result()
3402 
    result.read(self._iprot)
3403 
    self._iprot.readMessageEnd()
3404 
    if result.success is not None:
3405 
      return result.success
3406 
    if result.ex is not None:
3407 
      raise result.ex
3408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3409 
 
3410 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3411 
    """
3412 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3413 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3414 
 
3415 
    Parameters:
3416 
     - orderId
3417 
     - isAuthorized
3418 
    """
3419 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3420 
    return self.recv_markOrderDoaRequestAuthorized()
3421 
 
3422 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3423 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3424 
    args = markOrderDoaRequestAuthorized_args()
3425 
    args.orderId = orderId
3426 
    args.isAuthorized = isAuthorized
3427 
    args.write(self._oprot)
3428 
    self._oprot.writeMessageEnd()
3429 
    self._oprot.trans.flush()
3430 
 
3431 
  def recv_markOrderDoaRequestAuthorized(self, ):
3432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3433 
    if mtype == TMessageType.EXCEPTION:
3434 
      x = TApplicationException()
3435 
      x.read(self._iprot)
3436 
      self._iprot.readMessageEnd()
3437 
      raise x
3438 
    result = markOrderDoaRequestAuthorized_result()
3439 
    result.read(self._iprot)
3440 
    self._iprot.readMessageEnd()
3441 
    if result.success is not None:
3442 
      return result.success
3443 
    if result.ex is not None:
3444 
      raise result.ex
3445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3446 
 
4488 rajveer 3447 
  def markOrderReturnRequestReceived(self, orderId):
3448 
    """
3449 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3450 
 
3451 
    Parameters:
3452 
     - orderId
3453 
    """
3454 
    self.send_markOrderReturnRequestReceived(orderId)
3455 
    return self.recv_markOrderReturnRequestReceived()
3456 
 
3457 
  def send_markOrderReturnRequestReceived(self, orderId):
3458 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3459 
    args = markOrderReturnRequestReceived_args()
3460 
    args.orderId = orderId
3461 
    args.write(self._oprot)
3462 
    self._oprot.writeMessageEnd()
3463 
    self._oprot.trans.flush()
3464 
 
3465 
  def recv_markOrderReturnRequestReceived(self, ):
3466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3467 
    if mtype == TMessageType.EXCEPTION:
3468 
      x = TApplicationException()
3469 
      x.read(self._iprot)
3470 
      self._iprot.readMessageEnd()
3471 
      raise x
3472 
    result = markOrderReturnRequestReceived_result()
3473 
    result.read(self._iprot)
3474 
    self._iprot.readMessageEnd()
3475 
    if result.success is not None:
3476 
      return result.success
3477 
    if result.ex is not None:
3478 
      raise result.ex
3479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3480 
 
3481 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3482 
    """
3483 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3484 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3485 
 
3486 
    Parameters:
3487 
     - orderId
3488 
     - isAuthorized
3489 
    """
3490 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3491 
    return self.recv_markOrderReturnRequestAuthorized()
3492 
 
3493 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3494 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3495 
    args = markOrderReturnRequestAuthorized_args()
3496 
    args.orderId = orderId
3497 
    args.isAuthorized = isAuthorized
3498 
    args.write(self._oprot)
3499 
    self._oprot.writeMessageEnd()
3500 
    self._oprot.trans.flush()
3501 
 
3502 
  def recv_markOrderReturnRequestAuthorized(self, ):
3503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3504 
    if mtype == TMessageType.EXCEPTION:
3505 
      x = TApplicationException()
3506 
      x.read(self._iprot)
3507 
      self._iprot.readMessageEnd()
3508 
      raise x
3509 
    result = markOrderReturnRequestAuthorized_result()
3510 
    result.read(self._iprot)
3511 
    self._iprot.readMessageEnd()
3512 
    if result.success is not None:
3513 
      return result.success
3514 
    if result.ex is not None:
3515 
      raise result.ex
3516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3517 
 
4579 rajveer 3518 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3519 
    """
3520 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3521 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3522 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3523 
    For any other status, it returns false.
3524 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3525 
 
2536 chandransh 3526 
    Parameters:
3527 
     - orderId
4579 rajveer 3528 
     - providerId
2536 chandransh 3529 
    """
4579 rajveer 3530 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3531 
    return self.recv_requestPickupNumber()
3532 
 
4579 rajveer 3533 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3534 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3535 
    args = requestPickupNumber_args()
3536 
    args.orderId = orderId
4579 rajveer 3537 
    args.providerId = providerId
2536 chandransh 3538 
    args.write(self._oprot)
3539 
    self._oprot.writeMessageEnd()
3540 
    self._oprot.trans.flush()
3541 
 
3542 
  def recv_requestPickupNumber(self, ):
3543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3544 
    if mtype == TMessageType.EXCEPTION:
3545 
      x = TApplicationException()
3546 
      x.read(self._iprot)
3547 
      self._iprot.readMessageEnd()
3548 
      raise x
3549 
    result = requestPickupNumber_result()
3550 
    result.read(self._iprot)
3551 
    self._iprot.readMessageEnd()
3431 rajveer 3552 
    if result.success is not None:
2536 chandransh 3553 
      return result.success
3431 rajveer 3554 
    if result.ex is not None:
2536 chandransh 3555 
      raise result.ex
3556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3557 
 
4602 rajveer 3558 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3559 
    """
4452 rajveer 3560 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3561 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3562 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3563 
    	3. Returns true
2591 chandransh 3564 
    If the order is in any other status, it returns false.
2536 chandransh 3565 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3566 
 
2536 chandransh 3567 
    Parameters:
3568 
     - orderId
3569 
     - pickupNumber
4602 rajveer 3570 
     - providerId
2536 chandransh 3571 
    """
4602 rajveer 3572 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3573 
    return self.recv_authorizePickup()
3574 
 
4602 rajveer 3575 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3576 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3577 
    args = authorizePickup_args()
3578 
    args.orderId = orderId
3579 
    args.pickupNumber = pickupNumber
4602 rajveer 3580 
    args.providerId = providerId
2536 chandransh 3581 
    args.write(self._oprot)
3582 
    self._oprot.writeMessageEnd()
3583 
    self._oprot.trans.flush()
3584 
 
3585 
  def recv_authorizePickup(self, ):
3586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3587 
    if mtype == TMessageType.EXCEPTION:
3588 
      x = TApplicationException()
3589 
      x.read(self._iprot)
3590 
      self._iprot.readMessageEnd()
3591 
      raise x
3592 
    result = authorizePickup_result()
3593 
    result.read(self._iprot)
3594 
    self._iprot.readMessageEnd()
3431 rajveer 3595 
    if result.success is not None:
2536 chandransh 3596 
      return result.success
3431 rajveer 3597 
    if result.ex is not None:
2536 chandransh 3598 
      raise result.ex
3599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3600 
 
2764 chandransh 3601 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3602 
    """
3603 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3604 
 
2764 chandransh 3605 
    Parameters:
3606 
     - providerId
3607 
     - pickupDetails
3608 
    """
3609 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3610 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3611 
 
3612 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3613 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3614 
    args = markDoasAsPickedUp_args()
3615 
    args.providerId = providerId
3616 
    args.pickupDetails = pickupDetails
3617 
    args.write(self._oprot)
3618 
    self._oprot.writeMessageEnd()
3619 
    self._oprot.trans.flush()
3620 
 
3621 
  def recv_markDoasAsPickedUp(self, ):
3622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3623 
    if mtype == TMessageType.EXCEPTION:
3624 
      x = TApplicationException()
3625 
      x.read(self._iprot)
3626 
      self._iprot.readMessageEnd()
3627 
      raise x
3628 
    result = markDoasAsPickedUp_result()
3629 
    result.read(self._iprot)
3630 
    self._iprot.readMessageEnd()
4910 phani.kuma 3631 
    return
3632 
 
3633 
  def getDoasNotPickedUp(self, providerId):
3634 
    """
3635 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3636 
 
3637 
    Parameters:
3638 
     - providerId
3639 
    """
3640 
    self.send_getDoasNotPickedUp(providerId)
3641 
    return self.recv_getDoasNotPickedUp()
3642 
 
3643 
  def send_getDoasNotPickedUp(self, providerId):
3644 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3645 
    args = getDoasNotPickedUp_args()
3646 
    args.providerId = providerId
3647 
    args.write(self._oprot)
3648 
    self._oprot.writeMessageEnd()
3649 
    self._oprot.trans.flush()
3650 
 
3651 
  def recv_getDoasNotPickedUp(self, ):
3652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3653 
    if mtype == TMessageType.EXCEPTION:
3654 
      x = TApplicationException()
3655 
      x.read(self._iprot)
3656 
      self._iprot.readMessageEnd()
3657 
      raise x
3658 
    result = getDoasNotPickedUp_result()
3659 
    result.read(self._iprot)
3660 
    self._iprot.readMessageEnd()
3431 rajveer 3661 
    if result.success is not None:
2764 chandransh 3662 
      return result.success
4910 phani.kuma 3663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3664 
 
4741 phani.kuma 3665 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3666 
    """
3667 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3668 
 
3669 
    Parameters:
3670 
     - providerId
3671 
     - pickupDetails
3672 
    """
3673 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3674 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3675 
 
3676 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3677 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3678 
    args = markReturnOrdersAsPickedUp_args()
3679 
    args.providerId = providerId
3680 
    args.pickupDetails = pickupDetails
3681 
    args.write(self._oprot)
3682 
    self._oprot.writeMessageEnd()
3683 
    self._oprot.trans.flush()
3684 
 
3685 
  def recv_markReturnOrdersAsPickedUp(self, ):
3686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3687 
    if mtype == TMessageType.EXCEPTION:
3688 
      x = TApplicationException()
3689 
      x.read(self._iprot)
3690 
      self._iprot.readMessageEnd()
3691 
      raise x
3692 
    result = markReturnOrdersAsPickedUp_result()
3693 
    result.read(self._iprot)
3694 
    self._iprot.readMessageEnd()
4910 phani.kuma 3695 
    return
3696 
 
3697 
  def getReturnOrdersNotPickedUp(self, providerId):
3698 
    """
3699 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3700 
 
3701 
    Parameters:
3702 
     - providerId
3703 
    """
3704 
    self.send_getReturnOrdersNotPickedUp(providerId)
3705 
    return self.recv_getReturnOrdersNotPickedUp()
3706 
 
3707 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3708 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3709 
    args = getReturnOrdersNotPickedUp_args()
3710 
    args.providerId = providerId
3711 
    args.write(self._oprot)
3712 
    self._oprot.writeMessageEnd()
3713 
    self._oprot.trans.flush()
3714 
 
3715 
  def recv_getReturnOrdersNotPickedUp(self, ):
3716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3717 
    if mtype == TMessageType.EXCEPTION:
3718 
      x = TApplicationException()
3719 
      x.read(self._iprot)
3720 
      self._iprot.readMessageEnd()
3721 
      raise x
3722 
    result = getReturnOrdersNotPickedUp_result()
3723 
    result.read(self._iprot)
3724 
    self._iprot.readMessageEnd()
4741 phani.kuma 3725 
    if result.success is not None:
3726 
      return result.success
4910 phani.kuma 3727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3728 
 
4479 rajveer 3729 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3730 
    """
4452 rajveer 3731 
    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 3732 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3733 
    If the order is in any other state, it returns false.
3734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3735 
 
2591 chandransh 3736 
    Parameters:
3737 
     - orderId
4479 rajveer 3738 
     - receiveCondition
2591 chandransh 3739 
    """
4479 rajveer 3740 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3741 
    return self.recv_receiveReturn()
2536 chandransh 3742 
 
4479 rajveer 3743 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3744 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3745 
    args = receiveReturn_args()
2591 chandransh 3746 
    args.orderId = orderId
4479 rajveer 3747 
    args.receiveCondition = receiveCondition
2591 chandransh 3748 
    args.write(self._oprot)
3749 
    self._oprot.writeMessageEnd()
3750 
    self._oprot.trans.flush()
3751 
 
2616 chandransh 3752 
  def recv_receiveReturn(self, ):
2591 chandransh 3753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3754 
    if mtype == TMessageType.EXCEPTION:
3755 
      x = TApplicationException()
3756 
      x.read(self._iprot)
3757 
      self._iprot.readMessageEnd()
3758 
      raise x
2616 chandransh 3759 
    result = receiveReturn_result()
2591 chandransh 3760 
    result.read(self._iprot)
3761 
    self._iprot.readMessageEnd()
3431 rajveer 3762 
    if result.success is not None:
2591 chandransh 3763 
      return result.success
3431 rajveer 3764 
    if result.ex is not None:
2591 chandransh 3765 
      raise result.ex
2616 chandransh 3766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3767 
 
3768 
  def validateDoa(self, orderId, isValid):
3769 
    """
4452 rajveer 3770 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3771 
    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 3772 
    If the order is in any other state, it returns false.
3773 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3774 
 
2591 chandransh 3775 
    Parameters:
3776 
     - orderId
3777 
     - isValid
3778 
    """
3779 
    self.send_validateDoa(orderId, isValid)
3780 
    return self.recv_validateDoa()
3781 
 
3782 
  def send_validateDoa(self, orderId, isValid):
3783 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3784 
    args = validateDoa_args()
3785 
    args.orderId = orderId
3786 
    args.isValid = isValid
3787 
    args.write(self._oprot)
3788 
    self._oprot.writeMessageEnd()
3789 
    self._oprot.trans.flush()
3790 
 
3791 
  def recv_validateDoa(self, ):
3792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3793 
    if mtype == TMessageType.EXCEPTION:
3794 
      x = TApplicationException()
3795 
      x.read(self._iprot)
3796 
      self._iprot.readMessageEnd()
3797 
      raise x
3798 
    result = validateDoa_result()
3799 
    result.read(self._iprot)
3800 
    self._iprot.readMessageEnd()
3431 rajveer 3801 
    if result.success is not None:
2591 chandransh 3802 
      return result.success
3431 rajveer 3803 
    if result.ex is not None:
2591 chandransh 3804 
      raise result.ex
3805 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3806 
 
4495 rajveer 3807 
  def validateReturnProduct(self, orderId, isUsable):
3808 
    """
3809 
    Parameters:
3810 
     - orderId
3811 
     - isUsable
3812 
    """
3813 
    self.send_validateReturnProduct(orderId, isUsable)
3814 
    return self.recv_validateReturnProduct()
3815 
 
3816 
  def send_validateReturnProduct(self, orderId, isUsable):
3817 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3818 
    args = validateReturnProduct_args()
3819 
    args.orderId = orderId
3820 
    args.isUsable = isUsable
3821 
    args.write(self._oprot)
3822 
    self._oprot.writeMessageEnd()
3823 
    self._oprot.trans.flush()
3824 
 
3825 
  def recv_validateReturnProduct(self, ):
3826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3827 
    if mtype == TMessageType.EXCEPTION:
3828 
      x = TApplicationException()
3829 
      x.read(self._iprot)
3830 
      self._iprot.readMessageEnd()
3831 
      raise x
3832 
    result = validateReturnProduct_result()
3833 
    result.read(self._iprot)
3834 
    self._iprot.readMessageEnd()
3835 
    if result.success is not None:
3836 
      return result.success
3837 
    if result.ex is not None:
3838 
      raise result.ex
3839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3840 
 
2616 chandransh 3841 
  def reshipOrder(self, orderId):
3842 
    """
4484 rajveer 3843 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3844 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3845 
    	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 3846 
 
3847 
    If the order is in DOA_CERT_VALID state, it does the following:
3848 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3849 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3850 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3851 
 
2616 chandransh 3852 
    Returns the id of the newly created order.
3431 rajveer 3853 
 
2616 chandransh 3854 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3855 
 
2616 chandransh 3856 
    Parameters:
3857 
     - orderId
3858 
    """
3859 
    self.send_reshipOrder(orderId)
3860 
    return self.recv_reshipOrder()
2591 chandransh 3861 
 
2616 chandransh 3862 
  def send_reshipOrder(self, orderId):
3863 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3864 
    args = reshipOrder_args()
3865 
    args.orderId = orderId
3866 
    args.write(self._oprot)
3867 
    self._oprot.writeMessageEnd()
3868 
    self._oprot.trans.flush()
3869 
 
3870 
  def recv_reshipOrder(self, ):
3871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3872 
    if mtype == TMessageType.EXCEPTION:
3873 
      x = TApplicationException()
3874 
      x.read(self._iprot)
3875 
      self._iprot.readMessageEnd()
3876 
      raise x
3877 
    result = reshipOrder_result()
3878 
    result.read(self._iprot)
3879 
    self._iprot.readMessageEnd()
3431 rajveer 3880 
    if result.success is not None:
2616 chandransh 3881 
      return result.success
3431 rajveer 3882 
    if result.ex is not None:
2616 chandransh 3883 
      raise result.ex
3884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3885 
 
3226 chandransh 3886 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3887 
    """
4484 rajveer 3888 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3889 
    	1. Creates a refund request for batch processing.
3890 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3891 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3892 
 
2616 chandransh 3893 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3894 
    	1. Creates a refund request for batch processing.
3226 chandransh 3895 
    	2. Cancels the reservation of the item in the warehouse.
3896 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3897 
 
3226 chandransh 3898 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3899 
    	1. Cancels the reservation of the item in the warehouse.
3900 
    	2. Marks the current order as CANCELED.
3901 
 
3902 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3903 
 
2616 chandransh 3904 
    Returns True if it is successful, False otherwise.
3431 rajveer 3905 
 
2616 chandransh 3906 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3907 
 
2616 chandransh 3908 
    Parameters:
3909 
     - orderId
3226 chandransh 3910 
     - refundedBy
3911 
     - reason
2616 chandransh 3912 
    """
3226 chandransh 3913 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3914 
    return self.recv_refundOrder()
3915 
 
3226 chandransh 3916 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3917 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3918 
    args = refundOrder_args()
3919 
    args.orderId = orderId
3226 chandransh 3920 
    args.refundedBy = refundedBy
3921 
    args.reason = reason
2616 chandransh 3922 
    args.write(self._oprot)
3923 
    self._oprot.writeMessageEnd()
3924 
    self._oprot.trans.flush()
3925 
 
3926 
  def recv_refundOrder(self, ):
3927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3928 
    if mtype == TMessageType.EXCEPTION:
3929 
      x = TApplicationException()
3930 
      x.read(self._iprot)
3931 
      self._iprot.readMessageEnd()
3932 
      raise x
3933 
    result = refundOrder_result()
3934 
    result.read(self._iprot)
3935 
    self._iprot.readMessageEnd()
3431 rajveer 3936 
    if result.success is not None:
2616 chandransh 3937 
      return result.success
3431 rajveer 3938 
    if result.ex is not None:
2616 chandransh 3939 
      raise result.ex
3940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3941 
 
2690 chandransh 3942 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3943 
    """
3944 
    Get all return orders created between the from and to dates for the given warehouse.
3945 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3946 
 
2690 chandransh 3947 
    Parameters:
3948 
     - warehouseId
3949 
     - fromDate
3950 
     - toDate
3951 
    """
3952 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3953 
    return self.recv_getReturnOrders()
2616 chandransh 3954 
 
2690 chandransh 3955 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3956 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3957 
    args = getReturnOrders_args()
3958 
    args.warehouseId = warehouseId
3959 
    args.fromDate = fromDate
3960 
    args.toDate = toDate
3961 
    args.write(self._oprot)
3962 
    self._oprot.writeMessageEnd()
3963 
    self._oprot.trans.flush()
3964 
 
3965 
  def recv_getReturnOrders(self, ):
3966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3967 
    if mtype == TMessageType.EXCEPTION:
3968 
      x = TApplicationException()
3969 
      x.read(self._iprot)
3970 
      self._iprot.readMessageEnd()
3971 
      raise x
3972 
    result = getReturnOrders_result()
3973 
    result.read(self._iprot)
3974 
    self._iprot.readMessageEnd()
3431 rajveer 3975 
    if result.success is not None:
2690 chandransh 3976 
      return result.success
3977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3978 
 
5481 phani.kuma 3979 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3980 
    """
3981 
    Get all return orders created between the from and to dates.
3982 
 
3983 
    Parameters:
3984 
     - onlyNotProcessed
3985 
     - fromDate
3986 
     - toDate
3987 
    """
3988 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3989 
    return self.recv_getAllReturnOrders()
3990 
 
3991 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3992 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3993 
    args = getAllReturnOrders_args()
3994 
    args.onlyNotProcessed = onlyNotProcessed
3995 
    args.fromDate = fromDate
3996 
    args.toDate = toDate
3997 
    args.write(self._oprot)
3998 
    self._oprot.writeMessageEnd()
3999 
    self._oprot.trans.flush()
4000 
 
4001 
  def recv_getAllReturnOrders(self, ):
4002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4003 
    if mtype == TMessageType.EXCEPTION:
4004 
      x = TApplicationException()
4005 
      x.read(self._iprot)
4006 
      self._iprot.readMessageEnd()
4007 
      raise x
4008 
    result = getAllReturnOrders_result()
4009 
    result.read(self._iprot)
4010 
    self._iprot.readMessageEnd()
4011 
    if result.success is not None:
4012 
      return result.success
4013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4014 
 
2700 chandransh 4015 
  def getReturnOrder(self, id):
4016 
    """
4017 
    Returns the ReturnOrder corresponding to the given id.
4018 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4019 
 
2700 chandransh 4020 
    Parameters:
4021 
     - id
4022 
    """
4023 
    self.send_getReturnOrder(id)
4024 
    return self.recv_getReturnOrder()
4025 
 
4026 
  def send_getReturnOrder(self, id):
4027 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4028 
    args = getReturnOrder_args()
4029 
    args.id = id
4030 
    args.write(self._oprot)
4031 
    self._oprot.writeMessageEnd()
4032 
    self._oprot.trans.flush()
4033 
 
4034 
  def recv_getReturnOrder(self, ):
4035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4036 
    if mtype == TMessageType.EXCEPTION:
4037 
      x = TApplicationException()
4038 
      x.read(self._iprot)
4039 
      self._iprot.readMessageEnd()
4040 
      raise x
4041 
    result = getReturnOrder_result()
4042 
    result.read(self._iprot)
4043 
    self._iprot.readMessageEnd()
3431 rajveer 4044 
    if result.success is not None:
2700 chandransh 4045 
      return result.success
3431 rajveer 4046 
    if result.ex is not None:
2700 chandransh 4047 
      raise result.ex
4048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4049 
 
2690 chandransh 4050 
  def processReturn(self, returnOrderId):
4051 
    """
4052 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4053 
 
2690 chandransh 4054 
    Parameters:
4055 
     - returnOrderId
4056 
    """
4057 
    self.send_processReturn(returnOrderId)
4058 
    self.recv_processReturn()
4059 
 
4060 
  def send_processReturn(self, returnOrderId):
4061 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4062 
    args = processReturn_args()
4063 
    args.returnOrderId = returnOrderId
4064 
    args.write(self._oprot)
4065 
    self._oprot.writeMessageEnd()
4066 
    self._oprot.trans.flush()
4067 
 
4068 
  def recv_processReturn(self, ):
4069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4070 
    if mtype == TMessageType.EXCEPTION:
4071 
      x = TApplicationException()
4072 
      x.read(self._iprot)
4073 
      self._iprot.readMessageEnd()
4074 
      raise x
4075 
    result = processReturn_result()
4076 
    result.read(self._iprot)
4077 
    self._iprot.readMessageEnd()
3431 rajveer 4078 
    if result.ex is not None:
2690 chandransh 4079 
      raise result.ex
4080 
    return
4081 
 
3451 chandransh 4082 
  def updateWeight(self, orderId, weight):
4083 
    """
4084 
    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 4085 
 
3451 chandransh 4086 
    Parameters:
4087 
     - orderId
4088 
     - weight
4089 
    """
4090 
    self.send_updateWeight(orderId, weight)
4091 
    return self.recv_updateWeight()
4092 
 
4093 
  def send_updateWeight(self, orderId, weight):
4094 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4095 
    args = updateWeight_args()
4096 
    args.orderId = orderId
4097 
    args.weight = weight
4098 
    args.write(self._oprot)
4099 
    self._oprot.writeMessageEnd()
4100 
    self._oprot.trans.flush()
4101 
 
4102 
  def recv_updateWeight(self, ):
4103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4104 
    if mtype == TMessageType.EXCEPTION:
4105 
      x = TApplicationException()
4106 
      x.read(self._iprot)
4107 
      self._iprot.readMessageEnd()
4108 
      raise x
4109 
    result = updateWeight_result()
4110 
    result.read(self._iprot)
4111 
    self._iprot.readMessageEnd()
4112 
    if result.success is not None:
4113 
      return result.success
4114 
    if result.ex is not None:
4115 
      raise result.ex
4116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4117 
 
3469 chandransh 4118 
  def changeItem(self, orderId, itemId):
4119 
    """
4120 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4121 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4122 
 
3469 chandransh 4123 
    Parameters:
4124 
     - orderId
4125 
     - itemId
4126 
    """
4127 
    self.send_changeItem(orderId, itemId)
4128 
    return self.recv_changeItem()
4129 
 
4130 
  def send_changeItem(self, orderId, itemId):
4131 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4132 
    args = changeItem_args()
4133 
    args.orderId = orderId
4134 
    args.itemId = itemId
4135 
    args.write(self._oprot)
4136 
    self._oprot.writeMessageEnd()
4137 
    self._oprot.trans.flush()
4138 
 
4139 
  def recv_changeItem(self, ):
4140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4141 
    if mtype == TMessageType.EXCEPTION:
4142 
      x = TApplicationException()
4143 
      x.read(self._iprot)
4144 
      self._iprot.readMessageEnd()
4145 
      raise x
4146 
    result = changeItem_result()
4147 
    result.read(self._iprot)
4148 
    self._iprot.readMessageEnd()
4149 
    if result.success is not None:
4150 
      return result.success
4151 
    if result.ex is not None:
4152 
      raise result.ex
4153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4154 
 
4155 
  def shiftToWarehouse(self, orderId, warehouseId):
4156 
    """
4157 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4158 
 
4159 
    Parameters:
4160 
     - orderId
4161 
     - warehouseId
4162 
    """
4163 
    self.send_shiftToWarehouse(orderId, warehouseId)
4164 
    return self.recv_shiftToWarehouse()
4165 
 
4166 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4167 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4168 
    args = shiftToWarehouse_args()
4169 
    args.orderId = orderId
4170 
    args.warehouseId = warehouseId
4171 
    args.write(self._oprot)
4172 
    self._oprot.writeMessageEnd()
4173 
    self._oprot.trans.flush()
4174 
 
4175 
  def recv_shiftToWarehouse(self, ):
4176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4177 
    if mtype == TMessageType.EXCEPTION:
4178 
      x = TApplicationException()
4179 
      x.read(self._iprot)
4180 
      self._iprot.readMessageEnd()
4181 
      raise x
4182 
    result = shiftToWarehouse_result()
4183 
    result.read(self._iprot)
4184 
    self._iprot.readMessageEnd()
4185 
    if result.success is not None:
4186 
      return result.success
4187 
    if result.ex is not None:
4188 
      raise result.ex
4189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4190 
 
4647 rajveer 4191 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4192 
    """
4193 
    Adds the given delay reason to the given order.
3986 chandransh 4194 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4195 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4196 
 
3553 chandransh 4197 
    Parameters:
4198 
     - orderId
4199 
     - delayReason
3986 chandransh 4200 
     - furtherDelay
4647 rajveer 4201 
     - delayReasonText
3553 chandransh 4202 
    """
4647 rajveer 4203 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4204 
    return self.recv_addDelayReason()
4205 
 
4647 rajveer 4206 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4207 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4208 
    args = addDelayReason_args()
4209 
    args.orderId = orderId
4210 
    args.delayReason = delayReason
3986 chandransh 4211 
    args.furtherDelay = furtherDelay
4647 rajveer 4212 
    args.delayReasonText = delayReasonText
3553 chandransh 4213 
    args.write(self._oprot)
4214 
    self._oprot.writeMessageEnd()
4215 
    self._oprot.trans.flush()
4216 
 
4217 
  def recv_addDelayReason(self, ):
4218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4219 
    if mtype == TMessageType.EXCEPTION:
4220 
      x = TApplicationException()
4221 
      x.read(self._iprot)
4222 
      self._iprot.readMessageEnd()
4223 
      raise x
4224 
    result = addDelayReason_result()
4225 
    result.read(self._iprot)
4226 
    self._iprot.readMessageEnd()
4227 
    if result.success is not None:
4228 
      return result.success
4229 
    if result.ex is not None:
4230 
      raise result.ex
4231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4232 
 
3956 chandransh 4233 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4234 
    """
4235 
    Marks the COD orders with given AWB nos. as having been processed.
4236 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4237 
 
3956 chandransh 4238 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4239 
    1. There is no order corresponding to an AWB number.
4240 
    2. The captured amount for a payment exceeds the total payment.
4241 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4242 
 
4243 
    Parameters:
4244 
     - collectedAmountMap
4245 
     - xferBy
4246 
     - xferTxnId
4247 
     - xferDate
4248 
    """
4249 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4250 
    return self.recv_reconcileCodCollection()
4251 
 
4252 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4253 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4254 
    args = reconcileCodCollection_args()
4255 
    args.collectedAmountMap = collectedAmountMap
4256 
    args.xferBy = xferBy
4257 
    args.xferTxnId = xferTxnId
4258 
    args.xferDate = xferDate
4259 
    args.write(self._oprot)
4260 
    self._oprot.writeMessageEnd()
4261 
    self._oprot.trans.flush()
4262 
 
4263 
  def recv_reconcileCodCollection(self, ):
4264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4265 
    if mtype == TMessageType.EXCEPTION:
4266 
      x = TApplicationException()
4267 
      x.read(self._iprot)
4268 
      self._iprot.readMessageEnd()
4269 
      raise x
4270 
    result = reconcileCodCollection_result()
4271 
    result.read(self._iprot)
4272 
    self._iprot.readMessageEnd()
4273 
    if result.success is not None:
4274 
      return result.success
4275 
    if result.ex is not None:
4276 
      raise result.ex
4277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4278 
 
4008 mandeep.dh 4279 
  def getTransactionsRequiringExtraProcessing(self, category):
4280 
    """
4065 mandeep.dh 4281 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4282 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4283 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4284 
 
4008 mandeep.dh 4285 
    Parameters:
4286 
     - category
4287 
    """
4288 
    self.send_getTransactionsRequiringExtraProcessing(category)
4289 
    return self.recv_getTransactionsRequiringExtraProcessing()
4290 
 
4291 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4292 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4293 
    args = getTransactionsRequiringExtraProcessing_args()
4294 
    args.category = category
4295 
    args.write(self._oprot)
4296 
    self._oprot.writeMessageEnd()
4297 
    self._oprot.trans.flush()
4298 
 
4299 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4301 
    if mtype == TMessageType.EXCEPTION:
4302 
      x = TApplicationException()
4303 
      x.read(self._iprot)
4304 
      self._iprot.readMessageEnd()
4305 
      raise x
4306 
    result = getTransactionsRequiringExtraProcessing_result()
4307 
    result.read(self._iprot)
4308 
    self._iprot.readMessageEnd()
4309 
    if result.success is not None:
4310 
      return result.success
4311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4312 
 
4313 
  def markTransactionAsProcessed(self, transactionId, category):
4314 
    """
4315 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4316 
    It essentially deletes the transaction id record for a particular
4317 
    processing type category (if present) from DB.
4318 
    This is currently used by CRM application.
4008 mandeep.dh 4319 
 
4320 
    Parameters:
4321 
     - transactionId
4322 
     - category
4323 
    """
4324 
    self.send_markTransactionAsProcessed(transactionId, category)
4325 
    self.recv_markTransactionAsProcessed()
4326 
 
4327 
  def send_markTransactionAsProcessed(self, transactionId, category):
4328 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4329 
    args = markTransactionAsProcessed_args()
4330 
    args.transactionId = transactionId
4331 
    args.category = category
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_markTransactionAsProcessed(self, ):
4337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4338 
    if mtype == TMessageType.EXCEPTION:
4339 
      x = TApplicationException()
4340 
      x.read(self._iprot)
4341 
      self._iprot.readMessageEnd()
4342 
      raise x
4343 
    result = markTransactionAsProcessed_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    return
4347 
 
4018 chandransh 4348 
  def getItemWiseRiskyOrdersCount(self, ):
4349 
    """
4350 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4351 
    is defined as one whose shipping date is about to expire.
4352 
    """
4353 
    self.send_getItemWiseRiskyOrdersCount()
4354 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4355 
 
4018 chandransh 4356 
  def send_getItemWiseRiskyOrdersCount(self, ):
4357 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4358 
    args = getItemWiseRiskyOrdersCount_args()
4359 
    args.write(self._oprot)
4360 
    self._oprot.writeMessageEnd()
4361 
    self._oprot.trans.flush()
4362 
 
4363 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4365 
    if mtype == TMessageType.EXCEPTION:
4366 
      x = TApplicationException()
4367 
      x.read(self._iprot)
4368 
      self._iprot.readMessageEnd()
4369 
      raise x
4370 
    result = getItemWiseRiskyOrdersCount_result()
4371 
    result.read(self._iprot)
4372 
    self._iprot.readMessageEnd()
4373 
    if result.success is not None:
4374 
      return result.success
4375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4376 
 
4295 varun.gupt 4377 
  def getOrdersForItemIds(self, itemIds):
4378 
    """
4379 
    Returns a list of all orders which have items with given id
4380 
 
4381 
    Parameters:
4382 
     - itemIds
4383 
    """
4384 
    self.send_getOrdersForItemIds(itemIds)
4385 
    return self.recv_getOrdersForItemIds()
4386 
 
4387 
  def send_getOrdersForItemIds(self, itemIds):
4388 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4389 
    args = getOrdersForItemIds_args()
4390 
    args.itemIds = itemIds
4391 
    args.write(self._oprot)
4392 
    self._oprot.writeMessageEnd()
4393 
    self._oprot.trans.flush()
4394 
 
4395 
  def recv_getOrdersForItemIds(self, ):
4396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4397 
    if mtype == TMessageType.EXCEPTION:
4398 
      x = TApplicationException()
4399 
      x.read(self._iprot)
4400 
      self._iprot.readMessageEnd()
4401 
      raise x
4402 
    result = getOrdersForItemIds_result()
4403 
    result.read(self._iprot)
4404 
    self._iprot.readMessageEnd()
4405 
    if result.success is not None:
4406 
      return result.success
4407 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4408 
 
4247 rajveer 4409 
  def markOrderCancellationRequestReceived(self, orderId):
4410 
    """
4411 
    Mark order as cancellation request received. If customer sends request of cancellation of
4412 
    a particular order, this method will be called. It will just change status of the order
4413 
    depending on its current status. It also records the previous status, so that we can move
4414 
    back to that status if cancellation request is denied.
4018 chandransh 4415 
 
4247 rajveer 4416 
    Parameters:
4417 
     - orderId
4418 
    """
4419 
    self.send_markOrderCancellationRequestReceived(orderId)
4420 
    self.recv_markOrderCancellationRequestReceived()
4421 
 
4422 
  def send_markOrderCancellationRequestReceived(self, orderId):
4423 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4424 
    args = markOrderCancellationRequestReceived_args()
4425 
    args.orderId = orderId
4426 
    args.write(self._oprot)
4427 
    self._oprot.writeMessageEnd()
4428 
    self._oprot.trans.flush()
4429 
 
4430 
  def recv_markOrderCancellationRequestReceived(self, ):
4431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4432 
    if mtype == TMessageType.EXCEPTION:
4433 
      x = TApplicationException()
4434 
      x.read(self._iprot)
4435 
      self._iprot.readMessageEnd()
4436 
      raise x
4437 
    result = markOrderCancellationRequestReceived_result()
4438 
    result.read(self._iprot)
4439 
    self._iprot.readMessageEnd()
4440 
    if result.ex is not None:
4441 
      raise result.ex
4442 
    return
4443 
 
4444 
  def markOrderCancellationRequestConfirmed(self, orderId):
4445 
    """
4446 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4447 
    cancellation request confirmed. After this OM will be able to cancel the order.
4448 
 
4449 
    Parameters:
4450 
     - orderId
4451 
    """
4452 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4453 
    self.recv_markOrderCancellationRequestConfirmed()
4454 
 
4455 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4456 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4457 
    args = markOrderCancellationRequestConfirmed_args()
4458 
    args.orderId = orderId
4459 
    args.write(self._oprot)
4460 
    self._oprot.writeMessageEnd()
4461 
    self._oprot.trans.flush()
4462 
 
4463 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4465 
    if mtype == TMessageType.EXCEPTION:
4466 
      x = TApplicationException()
4467 
      x.read(self._iprot)
4468 
      self._iprot.readMessageEnd()
4469 
      raise x
4470 
    result = markOrderCancellationRequestConfirmed_result()
4471 
    result.read(self._iprot)
4472 
    self._iprot.readMessageEnd()
4473 
    if result.ex is not None:
4474 
      raise result.ex
4475 
    return
4476 
 
4477 
  def markOrderCancellationRequestDenied(self, orderId):
4478 
    """
4479 
    If we decide to not to cancel order, we will move the order ro previous status.
4480 
 
4481 
    Parameters:
4482 
     - orderId
4483 
    """
4484 
    self.send_markOrderCancellationRequestDenied(orderId)
4485 
    self.recv_markOrderCancellationRequestDenied()
4486 
 
4487 
  def send_markOrderCancellationRequestDenied(self, orderId):
4488 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4489 
    args = markOrderCancellationRequestDenied_args()
4490 
    args.orderId = orderId
4491 
    args.write(self._oprot)
4492 
    self._oprot.writeMessageEnd()
4493 
    self._oprot.trans.flush()
4494 
 
4495 
  def recv_markOrderCancellationRequestDenied(self, ):
4496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4497 
    if mtype == TMessageType.EXCEPTION:
4498 
      x = TApplicationException()
4499 
      x.read(self._iprot)
4500 
      self._iprot.readMessageEnd()
4501 
      raise x
4502 
    result = markOrderCancellationRequestDenied_result()
4503 
    result.read(self._iprot)
4504 
    self._iprot.readMessageEnd()
4505 
    if result.ex is not None:
4506 
      raise result.ex
4507 
    return
4508 
 
4258 rajveer 4509 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4510 
    """
4258 rajveer 4511 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4512 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4513 
 
4514 
    Parameters:
4258 rajveer 4515 
     - transactionId
4247 rajveer 4516 
    """
4258 rajveer 4517 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4518 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4519 
 
4258 rajveer 4520 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4521 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4522 
    args = markTransactionAsPaymentFlagRemoved_args()
4523 
    args.transactionId = transactionId
4247 rajveer 4524 
    args.write(self._oprot)
4525 
    self._oprot.writeMessageEnd()
4526 
    self._oprot.trans.flush()
4527 
 
4258 rajveer 4528 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4530 
    if mtype == TMessageType.EXCEPTION:
4531 
      x = TApplicationException()
4532 
      x.read(self._iprot)
4533 
      self._iprot.readMessageEnd()
4534 
      raise x
4258 rajveer 4535 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4536 
    result.read(self._iprot)
4537 
    self._iprot.readMessageEnd()
4538 
    if result.ex is not None:
4539 
      raise result.ex
4540 
    return
4541 
 
4259 anupam.sin 4542 
  def refundTransaction(self, transactionId, refundedBy, reason):
4543 
    """
4544 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4545 
    need to be cancelled
4247 rajveer 4546 
 
4259 anupam.sin 4547 
    Parameters:
4548 
     - transactionId
4549 
     - refundedBy
4550 
     - reason
4551 
    """
4552 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4553 
    self.recv_refundTransaction()
4554 
 
4555 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4556 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4557 
    args = refundTransaction_args()
4558 
    args.transactionId = transactionId
4559 
    args.refundedBy = refundedBy
4560 
    args.reason = reason
4561 
    args.write(self._oprot)
4562 
    self._oprot.writeMessageEnd()
4563 
    self._oprot.trans.flush()
4564 
 
4565 
  def recv_refundTransaction(self, ):
4566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4567 
    if mtype == TMessageType.EXCEPTION:
4568 
      x = TApplicationException()
4569 
      x.read(self._iprot)
4570 
      self._iprot.readMessageEnd()
4571 
      raise x
4572 
    result = refundTransaction_result()
4573 
    result.read(self._iprot)
4574 
    self._iprot.readMessageEnd()
4575 
    if result.ex is not None:
4576 
      raise result.ex
4577 
    return
4578 
 
4324 mandeep.dh 4579 
  def updateShipmentAddress(self, orderId, addressId):
4580 
    """
4581 
    Updates shipment address of an order. Delivery and shipping date estimates
4582 
    etc. are also updated here.
4583 
 
4584 
    Throws TransactionServiceException in case address change is not
4585 
    possible due to certain reasons such as new pincode in address is
4586 
    not serviceable etc.
4587 
 
4588 
    Parameters:
4589 
     - orderId
4590 
     - addressId
4591 
    """
4592 
    self.send_updateShipmentAddress(orderId, addressId)
4593 
    self.recv_updateShipmentAddress()
4594 
 
4595 
  def send_updateShipmentAddress(self, orderId, addressId):
4596 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4597 
    args = updateShipmentAddress_args()
4598 
    args.orderId = orderId
4599 
    args.addressId = addressId
4600 
    args.write(self._oprot)
4601 
    self._oprot.writeMessageEnd()
4602 
    self._oprot.trans.flush()
4603 
 
4604 
  def recv_updateShipmentAddress(self, ):
4605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4606 
    if mtype == TMessageType.EXCEPTION:
4607 
      x = TApplicationException()
4608 
      x.read(self._iprot)
4609 
      self._iprot.readMessageEnd()
4610 
      raise x
4611 
    result = updateShipmentAddress_result()
4612 
    result.read(self._iprot)
4613 
    self._iprot.readMessageEnd()
4614 
    if result.ex is not None:
4615 
      raise result.ex
4616 
    return
4617 
 
4285 rajveer 4618 
  def acceptOrdersForItemId(self, itemId, inventory):
4619 
    """
4620 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4621 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4622 
 
4285 rajveer 4623 
    Parameters:
4624 
     - itemId
4625 
     - inventory
4626 
    """
4627 
    self.send_acceptOrdersForItemId(itemId, inventory)
4628 
    return self.recv_acceptOrdersForItemId()
4629 
 
4630 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4631 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4632 
    args = acceptOrdersForItemId_args()
4633 
    args.itemId = itemId
4634 
    args.inventory = inventory
4635 
    args.write(self._oprot)
4636 
    self._oprot.writeMessageEnd()
4637 
    self._oprot.trans.flush()
4638 
 
4639 
  def recv_acceptOrdersForItemId(self, ):
4640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4641 
    if mtype == TMessageType.EXCEPTION:
4642 
      x = TApplicationException()
4643 
      x.read(self._iprot)
4644 
      self._iprot.readMessageEnd()
4645 
      raise x
4646 
    result = acceptOrdersForItemId_result()
4647 
    result.read(self._iprot)
4648 
    self._iprot.readMessageEnd()
4649 
    if result.success is not None:
4650 
      return result.success
4651 
    if result.ex is not None:
4652 
      raise result.ex
4653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4654 
 
4369 rajveer 4655 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4656 
    """
4657 
    Parameters:
4658 
     - vendorId
4659 
     - itemId
4660 
     - quantity
4661 
     - estimate
4369 rajveer 4662 
     - isReminder
4303 rajveer 4663 
    """
4369 rajveer 4664 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4665 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4666 
 
4369 rajveer 4667 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4668 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4669 
    args = markOrdersAsPORaised_args()
4670 
    args.vendorId = vendorId
4671 
    args.itemId = itemId
4672 
    args.quantity = quantity
4673 
    args.estimate = estimate
4369 rajveer 4674 
    args.isReminder = isReminder
4303 rajveer 4675 
    args.write(self._oprot)
4676 
    self._oprot.writeMessageEnd()
4677 
    self._oprot.trans.flush()
4678 
 
4679 
  def recv_markOrdersAsPORaised(self, ):
4680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4681 
    if mtype == TMessageType.EXCEPTION:
4682 
      x = TApplicationException()
4683 
      x.read(self._iprot)
4684 
      self._iprot.readMessageEnd()
4685 
      raise x
4686 
    result = markOrdersAsPORaised_result()
4687 
    result.read(self._iprot)
4688 
    self._iprot.readMessageEnd()
4689 
    if result.ex is not None:
4690 
      raise result.ex
4691 
    return
4692 
 
4369 rajveer 4693 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4694 
    """
4695 
    Parameters:
4696 
     - vendorId
4697 
     - itemId
4698 
     - quantity
4699 
     - estimate
4369 rajveer 4700 
     - isReminder
4303 rajveer 4701 
    """
4369 rajveer 4702 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4703 
    self.recv_markOrdersAsReversalInitiated()
4704 
 
4369 rajveer 4705 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4706 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4707 
    args = markOrdersAsReversalInitiated_args()
4708 
    args.vendorId = vendorId
4709 
    args.itemId = itemId
4710 
    args.quantity = quantity
4711 
    args.estimate = estimate
4369 rajveer 4712 
    args.isReminder = isReminder
4303 rajveer 4713 
    args.write(self._oprot)
4714 
    self._oprot.writeMessageEnd()
4715 
    self._oprot.trans.flush()
4716 
 
4717 
  def recv_markOrdersAsReversalInitiated(self, ):
4718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4719 
    if mtype == TMessageType.EXCEPTION:
4720 
      x = TApplicationException()
4721 
      x.read(self._iprot)
4722 
      self._iprot.readMessageEnd()
4723 
      raise x
4724 
    result = markOrdersAsReversalInitiated_result()
4725 
    result.read(self._iprot)
4726 
    self._iprot.readMessageEnd()
4727 
    if result.ex is not None:
4728 
      raise result.ex
4729 
    return
4730 
 
4369 rajveer 4731 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4732 
    """
4733 
    Parameters:
4734 
     - vendorId
4735 
     - itemId
4736 
     - quantity
4737 
     - estimate
4369 rajveer 4738 
     - isReminder
4303 rajveer 4739 
    """
4369 rajveer 4740 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4741 
    self.recv_markOrdersAsNotAvailabke()
4742 
 
4369 rajveer 4743 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4744 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4745 
    args = markOrdersAsNotAvailabke_args()
4746 
    args.vendorId = vendorId
4747 
    args.itemId = itemId
4748 
    args.quantity = quantity
4749 
    args.estimate = estimate
4369 rajveer 4750 
    args.isReminder = isReminder
4303 rajveer 4751 
    args.write(self._oprot)
4752 
    self._oprot.writeMessageEnd()
4753 
    self._oprot.trans.flush()
4754 
 
4755 
  def recv_markOrdersAsNotAvailabke(self, ):
4756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4757 
    if mtype == TMessageType.EXCEPTION:
4758 
      x = TApplicationException()
4759 
      x.read(self._iprot)
4760 
      self._iprot.readMessageEnd()
4761 
      raise x
4762 
    result = markOrdersAsNotAvailabke_result()
4763 
    result.read(self._iprot)
4764 
    self._iprot.readMessageEnd()
4765 
    if result.ex is not None:
4766 
      raise result.ex
4767 
    return
4768 
 
4369 rajveer 4769 
  def markOrdersAsTimeout(self, vendorId):
4770 
    """
4771 
    Parameters:
4772 
     - vendorId
4773 
    """
4774 
    self.send_markOrdersAsTimeout(vendorId)
4775 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4776 
 
4369 rajveer 4777 
  def send_markOrdersAsTimeout(self, vendorId):
4778 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4779 
    args = markOrdersAsTimeout_args()
4780 
    args.vendorId = vendorId
4781 
    args.write(self._oprot)
4782 
    self._oprot.writeMessageEnd()
4783 
    self._oprot.trans.flush()
4784 
 
4785 
  def recv_markOrdersAsTimeout(self, ):
4786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4787 
    if mtype == TMessageType.EXCEPTION:
4788 
      x = TApplicationException()
4789 
      x.read(self._iprot)
4790 
      self._iprot.readMessageEnd()
4791 
      raise x
4792 
    result = markOrdersAsTimeout_result()
4793 
    result.read(self._iprot)
4794 
    self._iprot.readMessageEnd()
4795 
    if result.success is not None:
4796 
      return result.success
4797 
    if result.ex is not None:
4798 
      raise result.ex
4799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4800 
 
4662 rajveer 4801 
  def markOrderAsLostInTransit(self, orderId):
4802 
    """
4803 
    Mark order as LOST_IN_TRANSIT
4804 
 
4805 
    Parameters:
4806 
     - orderId
4807 
    """
4808 
    self.send_markOrderAsLostInTransit(orderId)
4809 
    return self.recv_markOrderAsLostInTransit()
4810 
 
4811 
  def send_markOrderAsLostInTransit(self, orderId):
4812 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4813 
    args = markOrderAsLostInTransit_args()
4814 
    args.orderId = orderId
4815 
    args.write(self._oprot)
4816 
    self._oprot.writeMessageEnd()
4817 
    self._oprot.trans.flush()
4818 
 
4819 
  def recv_markOrderAsLostInTransit(self, ):
4820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4821 
    if mtype == TMessageType.EXCEPTION:
4822 
      x = TApplicationException()
4823 
      x.read(self._iprot)
4824 
      self._iprot.readMessageEnd()
4825 
      raise x
4826 
    result = markOrderAsLostInTransit_result()
4827 
    result.read(self._iprot)
4828 
    self._iprot.readMessageEnd()
4829 
    if result.success is not None:
4830 
      return result.success
4831 
    if result.ex is not None:
4832 
      raise result.ex
4833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4834 
 
4386 anupam.sin 4835 
  def getOrderForAwb(self, awb):
4836 
    """
4837 
    Returns the order corresponding to an AWB number
4369 rajveer 4838 
 
4386 anupam.sin 4839 
    Parameters:
4840 
     - awb
4841 
    """
4842 
    self.send_getOrderForAwb(awb)
4843 
    return self.recv_getOrderForAwb()
4844 
 
4845 
  def send_getOrderForAwb(self, awb):
4846 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4847 
    args = getOrderForAwb_args()
4848 
    args.awb = awb
4849 
    args.write(self._oprot)
4850 
    self._oprot.writeMessageEnd()
4851 
    self._oprot.trans.flush()
4852 
 
4853 
  def recv_getOrderForAwb(self, ):
4854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4855 
    if mtype == TMessageType.EXCEPTION:
4856 
      x = TApplicationException()
4857 
      x.read(self._iprot)
4858 
      self._iprot.readMessageEnd()
4859 
      raise x
4860 
    result = getOrderForAwb_result()
4861 
    result.read(self._iprot)
4862 
    self._iprot.readMessageEnd()
4863 
    if result.success is not None:
4864 
      return result.success
4865 
    if result.ex is not None:
4866 
      raise result.ex
4867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4868 
 
4910 phani.kuma 4869 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4870 
    """
4910 phani.kuma 4871 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4872 
 
4506 phani.kuma 4873 
    Parameters:
4874 
     - logistics_provider_id
4910 phani.kuma 4875 
     - order_status_list
4506 phani.kuma 4876 
    """
4910 phani.kuma 4877 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4878 
    return self.recv_getOrdersForProviderForStatus()
4879 
 
4910 phani.kuma 4880 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4881 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4882 
    args = getOrdersForProviderForStatus_args()
4883 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4884 
    args.order_status_list = order_status_list
4506 phani.kuma 4885 
    args.write(self._oprot)
4886 
    self._oprot.writeMessageEnd()
4887 
    self._oprot.trans.flush()
4888 
 
4889 
  def recv_getOrdersForProviderForStatus(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 = getOrdersForProviderForStatus_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, "getOrdersForProviderForStatus failed: unknown result");
4904 
 
4600 varun.gupt 4905 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4906 
    """
4907 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4908 
 
4600 varun.gupt 4909 
    Parameters:
4910 
     - vendorId
4911 
     - billingDateFrom
4912 
     - billingDateTo
4913 
    """
4914 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4915 
    return self.recv_getBilledOrdersForVendor()
4916 
 
4917 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4918 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4919 
    args = getBilledOrdersForVendor_args()
4920 
    args.vendorId = vendorId
4921 
    args.billingDateFrom = billingDateFrom
4922 
    args.billingDateTo = billingDateTo
4923 
    args.write(self._oprot)
4924 
    self._oprot.writeMessageEnd()
4925 
    self._oprot.trans.flush()
4926 
 
4927 
  def recv_getBilledOrdersForVendor(self, ):
4928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4929 
    if mtype == TMessageType.EXCEPTION:
4930 
      x = TApplicationException()
4931 
      x.read(self._iprot)
4932 
      self._iprot.readMessageEnd()
4933 
      raise x
4934 
    result = getBilledOrdersForVendor_result()
4935 
    result.read(self._iprot)
4936 
    self._iprot.readMessageEnd()
4937 
    if result.success is not None:
4938 
      return result.success
4939 
    if result.ex is not None:
4940 
      raise result.ex
4941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4942 
 
4607 rajveer 4943 
  def getSlippedSippingDateOrders(self, ):
4944 
    self.send_getSlippedSippingDateOrders()
4945 
    return self.recv_getSlippedSippingDateOrders()
4946 
 
4947 
  def send_getSlippedSippingDateOrders(self, ):
4948 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4949 
    args = getSlippedSippingDateOrders_args()
4950 
    args.write(self._oprot)
4951 
    self._oprot.writeMessageEnd()
4952 
    self._oprot.trans.flush()
4953 
 
4954 
  def recv_getSlippedSippingDateOrders(self, ):
4955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4956 
    if mtype == TMessageType.EXCEPTION:
4957 
      x = TApplicationException()
4958 
      x.read(self._iprot)
4959 
      self._iprot.readMessageEnd()
4960 
      raise x
4961 
    result = getSlippedSippingDateOrders_result()
4962 
    result.read(self._iprot)
4963 
    self._iprot.readMessageEnd()
4964 
    if result.success is not None:
4965 
      return result.success
4966 
    if result.ex is not None:
4967 
      raise result.ex
4968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4969 
 
4709 rajveer 4970 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4971 
    """
4972 
    Parameters:
4973 
     - cancelDateFrom
4974 
     - cancelDateTo
4975 
    """
4976 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4977 
    return self.recv_getCancelledOrders()
4978 
 
4979 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4980 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4981 
    args = getCancelledOrders_args()
4982 
    args.cancelDateFrom = cancelDateFrom
4983 
    args.cancelDateTo = cancelDateTo
4984 
    args.write(self._oprot)
4985 
    self._oprot.writeMessageEnd()
4986 
    self._oprot.trans.flush()
4987 
 
4988 
  def recv_getCancelledOrders(self, ):
4989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4990 
    if mtype == TMessageType.EXCEPTION:
4991 
      x = TApplicationException()
4992 
      x.read(self._iprot)
4993 
      self._iprot.readMessageEnd()
4994 
      raise x
4995 
    result = getCancelledOrders_result()
4996 
    result.read(self._iprot)
4997 
    self._iprot.readMessageEnd()
4998 
    if result.success is not None:
4999 
      return result.success
5000 
    if result.ex is not None:
5001 
      raise result.ex
5002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5003 
 
4600 varun.gupt 5004 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5005 
    """
5006 
    Parameters:
5007 
     - mapAWBAndAmount
5008 
    """
5009 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5010 
    self.recv_saveBluedartSettlements()
5011 
 
5012 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5013 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5014 
    args = saveBluedartSettlements_args()
5015 
    args.mapAWBAndAmount = mapAWBAndAmount
5016 
    args.write(self._oprot)
5017 
    self._oprot.writeMessageEnd()
5018 
    self._oprot.trans.flush()
5019 
 
5020 
  def recv_saveBluedartSettlements(self, ):
5021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5022 
    if mtype == TMessageType.EXCEPTION:
5023 
      x = TApplicationException()
5024 
      x.read(self._iprot)
5025 
      self._iprot.readMessageEnd()
5026 
      raise x
5027 
    result = saveBluedartSettlements_result()
5028 
    result.read(self._iprot)
5029 
    self._iprot.readMessageEnd()
5030 
    if result.ex is not None:
5031 
      raise result.ex
5032 
    return
5033 
 
4905 varun.gupt 5034 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5035 
    """
5036 
    Parameters:
5037 
     - settlementDate
5038 
     - paymentGatewayId
4905 varun.gupt 5039 
     - referenceId
4600 varun.gupt 5040 
     - serviceTax
5041 
     - otherCharges
5042 
     - netCollection
5043 
    """
4905 varun.gupt 5044 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5045 
    self.recv_savePaymentSettlements()
5046 
 
4905 varun.gupt 5047 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5048 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5049 
    args = savePaymentSettlements_args()
5050 
    args.settlementDate = settlementDate
5051 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5052 
    args.referenceId = referenceId
4600 varun.gupt 5053 
    args.serviceTax = serviceTax
5054 
    args.otherCharges = otherCharges
5055 
    args.netCollection = netCollection
5056 
    args.write(self._oprot)
5057 
    self._oprot.writeMessageEnd()
5058 
    self._oprot.trans.flush()
5059 
 
5060 
  def recv_savePaymentSettlements(self, ):
5061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5062 
    if mtype == TMessageType.EXCEPTION:
5063 
      x = TApplicationException()
5064 
      x.read(self._iprot)
5065 
      self._iprot.readMessageEnd()
5066 
      raise x
5067 
    result = savePaymentSettlements_result()
5068 
    result.read(self._iprot)
5069 
    self._iprot.readMessageEnd()
5070 
    if result.ex is not None:
5071 
      raise result.ex
5072 
    return
5073 
 
5074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5075 
    """
5076 
    Parameters:
5077 
     - settlementId
5078 
     - settlementDate
5079 
     - transactionDateFrom
5080 
     - transactionDateTo
5081 
     - amount
5082 
    """
5083 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5084 
    self.recv_saveEBSSettlementSummary()
5085 
 
5086 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5087 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5088 
    args = saveEBSSettlementSummary_args()
5089 
    args.settlementId = settlementId
5090 
    args.settlementDate = settlementDate
5091 
    args.transactionDateFrom = transactionDateFrom
5092 
    args.transactionDateTo = transactionDateTo
5093 
    args.amount = amount
5094 
    args.write(self._oprot)
5095 
    self._oprot.writeMessageEnd()
5096 
    self._oprot.trans.flush()
5097 
 
5098 
  def recv_saveEBSSettlementSummary(self, ):
5099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5100 
    if mtype == TMessageType.EXCEPTION:
5101 
      x = TApplicationException()
5102 
      x.read(self._iprot)
5103 
      self._iprot.readMessageEnd()
5104 
      raise x
5105 
    result = saveEBSSettlementSummary_result()
5106 
    result.read(self._iprot)
5107 
    self._iprot.readMessageEnd()
5108 
    if result.ex is not None:
5109 
      raise result.ex
5110 
    return
5111 
 
5386 phani.kuma 5112 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5113 
    """
5114 
    Parameters:
5189 varun.gupt 5115 
     - referenceId
5116 
     - isRefund
4600 varun.gupt 5117 
    """
5386 phani.kuma 5118 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5119 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5120 
 
5386 phani.kuma 5121 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5122 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5123 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5124 
    args.referenceId = referenceId
5125 
    args.isRefund = isRefund
4600 varun.gupt 5126 
    args.write(self._oprot)
5127 
    self._oprot.writeMessageEnd()
5128 
    self._oprot.trans.flush()
5129 
 
5386 phani.kuma 5130 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5132 
    if mtype == TMessageType.EXCEPTION:
5133 
      x = TApplicationException()
5134 
      x.read(self._iprot)
5135 
      self._iprot.readMessageEnd()
5136 
      raise x
5386 phani.kuma 5137 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5138 
    result.read(self._iprot)
5139 
    self._iprot.readMessageEnd()
5140 
    if result.success is not None:
5141 
      return result.success
5142 
    if result.ex is not None:
5143 
      raise result.ex
5386 phani.kuma 5144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5145 
 
5386 phani.kuma 5146 
  def getSettlementForCod(self, orderId, isRefund):
5147 
    """
5148 
    Parameters:
5149 
     - orderId
5150 
     - isRefund
5151 
    """
5152 
    self.send_getSettlementForCod(orderId, isRefund)
5153 
    return self.recv_getSettlementForCod()
5154 
 
5155 
  def send_getSettlementForCod(self, orderId, isRefund):
5156 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5157 
    args = getSettlementForCod_args()
5158 
    args.orderId = orderId
5159 
    args.isRefund = isRefund
5160 
    args.write(self._oprot)
5161 
    self._oprot.writeMessageEnd()
5162 
    self._oprot.trans.flush()
5163 
 
5164 
  def recv_getSettlementForCod(self, ):
5165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5166 
    if mtype == TMessageType.EXCEPTION:
5167 
      x = TApplicationException()
5168 
      x.read(self._iprot)
5169 
      self._iprot.readMessageEnd()
5170 
      raise x
5171 
    result = getSettlementForCod_result()
5172 
    result.read(self._iprot)
5173 
    self._iprot.readMessageEnd()
5174 
    if result.success is not None:
5175 
      return result.success
5176 
    if result.ex is not None:
5177 
      raise result.ex
5178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5179 
 
4600 varun.gupt 5180 
  def getEBSSettlementSummaries(self, ):
5181 
    self.send_getEBSSettlementSummaries()
5182 
    return self.recv_getEBSSettlementSummaries()
5183 
 
5184 
  def send_getEBSSettlementSummaries(self, ):
5185 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5186 
    args = getEBSSettlementSummaries_args()
5187 
    args.write(self._oprot)
5188 
    self._oprot.writeMessageEnd()
5189 
    self._oprot.trans.flush()
5190 
 
5191 
  def recv_getEBSSettlementSummaries(self, ):
5192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5193 
    if mtype == TMessageType.EXCEPTION:
5194 
      x = TApplicationException()
5195 
      x.read(self._iprot)
5196 
      self._iprot.readMessageEnd()
5197 
      raise x
5198 
    result = getEBSSettlementSummaries_result()
5199 
    result.read(self._iprot)
5200 
    self._iprot.readMessageEnd()
5201 
    if result.success is not None:
5202 
      return result.success
5203 
    if result.ex is not None:
5204 
      raise result.ex
5205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5206 
 
5207 
  def markEBSSettlementUploaded(self, settlementId):
5208 
    """
5209 
    Parameters:
5210 
     - settlementId
5211 
    """
5212 
    self.send_markEBSSettlementUploaded(settlementId)
5213 
    self.recv_markEBSSettlementUploaded()
5214 
 
5215 
  def send_markEBSSettlementUploaded(self, settlementId):
5216 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5217 
    args = markEBSSettlementUploaded_args()
5218 
    args.settlementId = settlementId
5219 
    args.write(self._oprot)
5220 
    self._oprot.writeMessageEnd()
5221 
    self._oprot.trans.flush()
5222 
 
5223 
  def recv_markEBSSettlementUploaded(self, ):
5224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5225 
    if mtype == TMessageType.EXCEPTION:
5226 
      x = TApplicationException()
5227 
      x.read(self._iprot)
5228 
      self._iprot.readMessageEnd()
5229 
      raise x
5230 
    result = markEBSSettlementUploaded_result()
5231 
    result.read(self._iprot)
5232 
    self._iprot.readMessageEnd()
5233 
    if result.ex is not None:
5234 
      raise result.ex
5235 
    return
5236 
 
5237 
  def getEBSSettlementDate(self, settlementId):
5238 
    """
5239 
    Parameters:
5240 
     - settlementId
5241 
    """
5242 
    self.send_getEBSSettlementDate(settlementId)
5243 
    return self.recv_getEBSSettlementDate()
5244 
 
5245 
  def send_getEBSSettlementDate(self, settlementId):
5246 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5247 
    args = getEBSSettlementDate_args()
5248 
    args.settlementId = settlementId
5249 
    args.write(self._oprot)
5250 
    self._oprot.writeMessageEnd()
5251 
    self._oprot.trans.flush()
5252 
 
5253 
  def recv_getEBSSettlementDate(self, ):
5254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5255 
    if mtype == TMessageType.EXCEPTION:
5256 
      x = TApplicationException()
5257 
      x.read(self._iprot)
5258 
      self._iprot.readMessageEnd()
5259 
      raise x
5260 
    result = getEBSSettlementDate_result()
5261 
    result.read(self._iprot)
5262 
    self._iprot.readMessageEnd()
5263 
    if result.success is not None:
5264 
      return result.success
5265 
    if result.ex is not None:
5266 
      raise result.ex
5267 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5268 
 
4715 varun.gupt 5269 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5270 
    """
5271 
    Parameters:
5272 
     - settlementDateFrom
5273 
     - settlementDateTo
5274 
     - isRefund
5275 
    """
5276 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5277 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5278 
 
4715 varun.gupt 5279 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5280 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5281 
    args = getSettlementsByDate_args()
5282 
    args.settlementDateFrom = settlementDateFrom
5283 
    args.settlementDateTo = settlementDateTo
5284 
    args.isRefund = isRefund
5285 
    args.write(self._oprot)
5286 
    self._oprot.writeMessageEnd()
5287 
    self._oprot.trans.flush()
5288 
 
5289 
  def recv_getSettlementsByDate(self, ):
5290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5291 
    if mtype == TMessageType.EXCEPTION:
5292 
      x = TApplicationException()
5293 
      x.read(self._iprot)
5294 
      self._iprot.readMessageEnd()
5295 
      raise x
5296 
    result = getSettlementsByDate_result()
5297 
    result.read(self._iprot)
5298 
    self._iprot.readMessageEnd()
5299 
    if result.success is not None:
5300 
      return result.success
5301 
    if result.ex is not None:
5302 
      raise result.ex
5303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5304 
 
5305 
  def getReshippedOrderIds(self, orderIds):
5306 
    """
5307 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5308 
 
5309 
    Parameters:
5310 
     - orderIds
5311 
    """
5312 
    self.send_getReshippedOrderIds(orderIds)
5313 
    return self.recv_getReshippedOrderIds()
5314 
 
5315 
  def send_getReshippedOrderIds(self, orderIds):
5316 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5317 
    args = getReshippedOrderIds_args()
5318 
    args.orderIds = orderIds
5319 
    args.write(self._oprot)
5320 
    self._oprot.writeMessageEnd()
5321 
    self._oprot.trans.flush()
5322 
 
5323 
  def recv_getReshippedOrderIds(self, ):
5324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5325 
    if mtype == TMessageType.EXCEPTION:
5326 
      x = TApplicationException()
5327 
      x.read(self._iprot)
5328 
      self._iprot.readMessageEnd()
5329 
      raise x
5330 
    result = getReshippedOrderIds_result()
5331 
    result.read(self._iprot)
5332 
    self._iprot.readMessageEnd()
5333 
    if result.success is not None:
5334 
      return result.success
5335 
    if result.ex is not None:
5336 
      raise result.ex
5337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5338 
 
5481 phani.kuma 5339 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5340 
    """
5341 
    Parameters:
5342 
     - vendorId
5481 phani.kuma 5343 
     - onlyVendorNotPaid
5344 
     - billingDateFrom
5345 
     - billingDateTo
4875 varun.gupt 5346 
    """
5481 phani.kuma 5347 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5348 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5349 
 
5481 phani.kuma 5350 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5351 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5352 
    args = getBilledOrders_args()
4875 varun.gupt 5353 
    args.vendorId = vendorId
5481 phani.kuma 5354 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5355 
    args.billingDateFrom = billingDateFrom
5356 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5357 
    args.write(self._oprot)
5358 
    self._oprot.writeMessageEnd()
5359 
    self._oprot.trans.flush()
5360 
 
5481 phani.kuma 5361 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5363 
    if mtype == TMessageType.EXCEPTION:
5364 
      x = TApplicationException()
5365 
      x.read(self._iprot)
5366 
      self._iprot.readMessageEnd()
5367 
      raise x
5481 phani.kuma 5368 
    result = getBilledOrders_result()
4875 varun.gupt 5369 
    result.read(self._iprot)
5370 
    self._iprot.readMessageEnd()
5371 
    if result.success is not None:
5372 
      return result.success
5373 
    if result.ex is not None:
5374 
      raise result.ex
5481 phani.kuma 5375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5376 
 
5031 varun.gupt 5377 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5378 
    """
5379 
    Parameters:
5380 
     - startDate
5381 
     - endDate
5382 
    """
5383 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5384 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5385 
 
5031 varun.gupt 5386 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5387 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5388 
    args = getStatusDistributionOfOrders_args()
5389 
    args.startDate = startDate
5390 
    args.endDate = endDate
5391 
    args.write(self._oprot)
5392 
    self._oprot.writeMessageEnd()
5393 
    self._oprot.trans.flush()
5394 
 
5395 
  def recv_getStatusDistributionOfOrders(self, ):
5396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5397 
    if mtype == TMessageType.EXCEPTION:
5398 
      x = TApplicationException()
5399 
      x.read(self._iprot)
5400 
      self._iprot.readMessageEnd()
5401 
      raise x
5402 
    result = getStatusDistributionOfOrders_result()
5403 
    result.read(self._iprot)
5404 
    self._iprot.readMessageEnd()
5405 
    if result.success is not None:
5406 
      return result.success
5407 
    if result.ex is not None:
5408 
      raise result.ex
5409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5410 
 
5067 varun.gupt 5411 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5412 
    """
5413 
    Parameters:
5414 
     - status
5415 
     - startDatetime
5416 
     - endDatetime
5417 
    """
5418 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5419 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5420 
 
5067 varun.gupt 5421 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5422 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5423 
    args = getOrderIdsForStatus_args()
5424 
    args.status = status
5425 
    args.startDatetime = startDatetime
5426 
    args.endDatetime = endDatetime
5427 
    args.write(self._oprot)
5428 
    self._oprot.writeMessageEnd()
5429 
    self._oprot.trans.flush()
5430 
 
5431 
  def recv_getOrderIdsForStatus(self, ):
5432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5433 
    if mtype == TMessageType.EXCEPTION:
5434 
      x = TApplicationException()
5435 
      x.read(self._iprot)
5436 
      self._iprot.readMessageEnd()
5437 
      raise x
5438 
    result = getOrderIdsForStatus_result()
5439 
    result.read(self._iprot)
5440 
    self._iprot.readMessageEnd()
5441 
    if result.success is not None:
5442 
      return result.success
5443 
    if result.ex is not None:
5444 
      raise result.ex
5445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5446 
 
5348 anupam.sin 5447 
  def updateCODAgent(self, agent, orderId):
5448 
    """
5449 
    Updates the agent who handled the COD verification call
5450 
 
5451 
    Parameters:
5452 
     - agent
5453 
     - orderId
5454 
    """
5455 
    self.send_updateCODAgent(agent, orderId)
5456 
    self.recv_updateCODAgent()
5457 
 
5458 
  def send_updateCODAgent(self, agent, orderId):
5459 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5460 
    args = updateCODAgent_args()
5461 
    args.agent = agent
5462 
    args.orderId = orderId
5463 
    args.write(self._oprot)
5464 
    self._oprot.writeMessageEnd()
5465 
    self._oprot.trans.flush()
5466 
 
5467 
  def recv_updateCODAgent(self, ):
5468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5469 
    if mtype == TMessageType.EXCEPTION:
5470 
      x = TApplicationException()
5471 
      x.read(self._iprot)
5472 
      self._iprot.readMessageEnd()
5473 
      raise x
5474 
    result = updateCODAgent_result()
5475 
    result.read(self._iprot)
5476 
    self._iprot.readMessageEnd()
5477 
    if result.ex is not None:
5478 
      raise result.ex
5479 
    return
5480 
 
5099 varun.gupt 5481 
  def updateOrderAsPaidToVendor(self, orderId):
5482 
    """
5483 
    Parameters:
5484 
     - orderId
5485 
    """
5486 
    self.send_updateOrderAsPaidToVendor(orderId)
5487 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5488 
 
5099 varun.gupt 5489 
  def send_updateOrderAsPaidToVendor(self, orderId):
5490 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5491 
    args = updateOrderAsPaidToVendor_args()
5492 
    args.orderId = orderId
5493 
    args.write(self._oprot)
5494 
    self._oprot.writeMessageEnd()
5495 
    self._oprot.trans.flush()
5496 
 
5497 
  def recv_updateOrderAsPaidToVendor(self, ):
5498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5499 
    if mtype == TMessageType.EXCEPTION:
5500 
      x = TApplicationException()
5501 
      x.read(self._iprot)
5502 
      self._iprot.readMessageEnd()
5503 
      raise x
5504 
    result = updateOrderAsPaidToVendor_result()
5505 
    result.read(self._iprot)
5506 
    self._iprot.readMessageEnd()
5507 
    if result.ex is not None:
5508 
      raise result.ex
5509 
    return
5510 
 
5386 phani.kuma 5511 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5512 
    """
5513 
    Parameters:
5514 
     - orderId
5515 
    """
5516 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5517 
    self.recv_updateOrderOnlyAsPaidToVendor()
5518 
 
5519 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5520 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5521 
    args = updateOrderOnlyAsPaidToVendor_args()
5522 
    args.orderId = orderId
5523 
    args.write(self._oprot)
5524 
    self._oprot.writeMessageEnd()
5525 
    self._oprot.trans.flush()
5526 
 
5527 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5529 
    if mtype == TMessageType.EXCEPTION:
5530 
      x = TApplicationException()
5531 
      x.read(self._iprot)
5532 
      self._iprot.readMessageEnd()
5533 
      raise x
5534 
    result = updateOrderOnlyAsPaidToVendor_result()
5535 
    result.read(self._iprot)
5536 
    self._iprot.readMessageEnd()
5537 
    if result.ex is not None:
5538 
      raise result.ex
5539 
    return
5540 
 
5208 varun.gupt 5541 
  def getRefundedOrdersMarkedPaid(self, ):
5542 
    self.send_getRefundedOrdersMarkedPaid()
5543 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5544 
 
5208 varun.gupt 5545 
  def send_getRefundedOrdersMarkedPaid(self, ):
5546 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5547 
    args = getRefundedOrdersMarkedPaid_args()
5548 
    args.write(self._oprot)
5549 
    self._oprot.writeMessageEnd()
5550 
    self._oprot.trans.flush()
5551 
 
5552 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5553 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5554 
    if mtype == TMessageType.EXCEPTION:
5555 
      x = TApplicationException()
5556 
      x.read(self._iprot)
5557 
      self._iprot.readMessageEnd()
5558 
      raise x
5559 
    result = getRefundedOrdersMarkedPaid_result()
5560 
    result.read(self._iprot)
5561 
    self._iprot.readMessageEnd()
5562 
    if result.success is not None:
5563 
      return result.success
5564 
    if result.ex is not None:
5565 
      raise result.ex
5566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5567 
 
5447 anupam.sin 5568 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5569 
    """
5570 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5571 
 
5447 anupam.sin 5572 
 
5573 
    Parameters:
5574 
     - minOrderId
5575 
     - maxOrderId
5576 
    """
5577 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5578 
    return self.recv_getAllVerificationAgents()
5579 
 
5580 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5581 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5582 
    args = getAllVerificationAgents_args()
5583 
    args.minOrderId = minOrderId
5584 
    args.maxOrderId = maxOrderId
5585 
    args.write(self._oprot)
5586 
    self._oprot.writeMessageEnd()
5587 
    self._oprot.trans.flush()
5588 
 
5589 
  def recv_getAllVerificationAgents(self, ):
5590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5591 
    if mtype == TMessageType.EXCEPTION:
5592 
      x = TApplicationException()
5593 
      x.read(self._iprot)
5594 
      self._iprot.readMessageEnd()
5595 
      raise x
5596 
    result = getAllVerificationAgents_result()
5597 
    result.read(self._iprot)
5598 
    self._iprot.readMessageEnd()
5599 
    if result.success is not None:
5600 
      return result.success
5601 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5602 
 
5527 anupam.sin 5603 
  def getAllAttributesForOrderId(self, orderId):
5604 
    """
5605 
    gets all attributes for a given orderId
5447 anupam.sin 5606 
 
5527 anupam.sin 5607 
    Parameters:
5608 
     - orderId
5609 
    """
5610 
    self.send_getAllAttributesForOrderId(orderId)
5611 
    return self.recv_getAllAttributesForOrderId()
5612 
 
5613 
  def send_getAllAttributesForOrderId(self, orderId):
5614 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5615 
    args = getAllAttributesForOrderId_args()
5616 
    args.orderId = orderId
5617 
    args.write(self._oprot)
5618 
    self._oprot.writeMessageEnd()
5619 
    self._oprot.trans.flush()
5620 
 
5621 
  def recv_getAllAttributesForOrderId(self, ):
5622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5623 
    if mtype == TMessageType.EXCEPTION:
5624 
      x = TApplicationException()
5625 
      x.read(self._iprot)
5626 
      self._iprot.readMessageEnd()
5627 
      raise x
5628 
    result = getAllAttributesForOrderId_result()
5629 
    result.read(self._iprot)
5630 
    self._iprot.readMessageEnd()
5631 
    if result.success is not None:
5632 
      return result.success
5633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5634 
 
5676 rajveer 5635 
  def setOrderAttributes(self, orderId, attributes):
5636 
    """
5637 
    sets attributes for an order
5638 
 
5639 
    Parameters:
5640 
     - orderId
5641 
     - attributes
5642 
    """
5643 
    self.send_setOrderAttributes(orderId, attributes)
5644 
    self.recv_setOrderAttributes()
5645 
 
5646 
  def send_setOrderAttributes(self, orderId, attributes):
5647 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5648 
    args = setOrderAttributes_args()
5649 
    args.orderId = orderId
5650 
    args.attributes = attributes
5651 
    args.write(self._oprot)
5652 
    self._oprot.writeMessageEnd()
5653 
    self._oprot.trans.flush()
5654 
 
5655 
  def recv_setOrderAttributes(self, ):
5656 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5657 
    if mtype == TMessageType.EXCEPTION:
5658 
      x = TApplicationException()
5659 
      x.read(self._iprot)
5660 
      self._iprot.readMessageEnd()
5661 
      raise x
5662 
    result = setOrderAttributes_result()
5663 
    result.read(self._iprot)
5664 
    self._iprot.readMessageEnd()
5665 
    return
5666 
 
5527 anupam.sin 5667 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5668 
    """
5669 
    sets attributes for all orders in a transaction
5670 
 
5671 
    Parameters:
5672 
     - transactionId
5673 
     - attribute
5674 
    """
5675 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5676 
    self.recv_setOrderAttributeForTransaction()
5677 
 
5678 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5679 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5680 
    args = setOrderAttributeForTransaction_args()
5681 
    args.transactionId = transactionId
5682 
    args.attribute = attribute
5683 
    args.write(self._oprot)
5684 
    self._oprot.writeMessageEnd()
5685 
    self._oprot.trans.flush()
5686 
 
5687 
  def recv_setOrderAttributeForTransaction(self, ):
5688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5689 
    if mtype == TMessageType.EXCEPTION:
5690 
      x = TApplicationException()
5691 
      x.read(self._iprot)
5692 
      self._iprot.readMessageEnd()
5693 
      raise x
5694 
    result = setOrderAttributeForTransaction_result()
5695 
    result.read(self._iprot)
5696 
    self._iprot.readMessageEnd()
5697 
    return
5698 
 
5553 rajveer 5699 
  def getReceivePendingOrders(self, storeId):
5700 
    """
5701 
    Parameters:
5702 
     - storeId
5703 
    """
5704 
    self.send_getReceivePendingOrders(storeId)
5705 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5706 
 
5553 rajveer 5707 
  def send_getReceivePendingOrders(self, storeId):
5708 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5709 
    args = getReceivePendingOrders_args()
5710 
    args.storeId = storeId
5711 
    args.write(self._oprot)
5712 
    self._oprot.writeMessageEnd()
5713 
    self._oprot.trans.flush()
5714 
 
5715 
  def recv_getReceivePendingOrders(self, ):
5716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5717 
    if mtype == TMessageType.EXCEPTION:
5718 
      x = TApplicationException()
5719 
      x.read(self._iprot)
5720 
      self._iprot.readMessageEnd()
5721 
      raise x
5722 
    result = getReceivePendingOrders_result()
5723 
    result.read(self._iprot)
5724 
    self._iprot.readMessageEnd()
5725 
    if result.success is not None:
5726 
      return result.success
5727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5728 
 
5729 
  def getReceivedAtStoreOrders(self, storeId):
5730 
    """
5731 
    Parameters:
5732 
     - storeId
5733 
    """
5734 
    self.send_getReceivedAtStoreOrders(storeId)
5735 
    return self.recv_getReceivedAtStoreOrders()
5736 
 
5737 
  def send_getReceivedAtStoreOrders(self, storeId):
5738 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5739 
    args = getReceivedAtStoreOrders_args()
5740 
    args.storeId = storeId
5741 
    args.write(self._oprot)
5742 
    self._oprot.writeMessageEnd()
5743 
    self._oprot.trans.flush()
5744 
 
5745 
  def recv_getReceivedAtStoreOrders(self, ):
5746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5747 
    if mtype == TMessageType.EXCEPTION:
5748 
      x = TApplicationException()
5749 
      x.read(self._iprot)
5750 
      self._iprot.readMessageEnd()
5751 
      raise x
5752 
    result = getReceivedAtStoreOrders_result()
5753 
    result.read(self._iprot)
5754 
    self._iprot.readMessageEnd()
5755 
    if result.success is not None:
5756 
      return result.success
5757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5758 
 
5713 rajveer 5759 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5760 
    """
5761 
    Parameters:
5762 
     - storeId
5763 
     - fromDate
5764 
     - toDate
5765 
     - onlyCod
5766 
    """
5767 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5768 
    return self.recv_getOrdersCollectionAtStore()
5769 
 
5770 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5771 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5772 
    args = getOrdersCollectionAtStore_args()
5773 
    args.storeId = storeId
5774 
    args.fromDate = fromDate
5775 
    args.toDate = toDate
5776 
    args.onlyCod = onlyCod
5777 
    args.write(self._oprot)
5778 
    self._oprot.writeMessageEnd()
5779 
    self._oprot.trans.flush()
5780 
 
5781 
  def recv_getOrdersCollectionAtStore(self, ):
5782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5783 
    if mtype == TMessageType.EXCEPTION:
5784 
      x = TApplicationException()
5785 
      x.read(self._iprot)
5786 
      self._iprot.readMessageEnd()
5787 
      raise x
5788 
    result = getOrdersCollectionAtStore_result()
5789 
    result.read(self._iprot)
5790 
    self._iprot.readMessageEnd()
5791 
    if result.success is not None:
5792 
      return result.success
5793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5794 
 
5833 rajveer 5795 
  def getOrderAttributeValue(self, orderId, attributeName):
5796 
    """
5797 
    Parameters:
5798 
     - orderId
5799 
     - attributeName
5800 
    """
5801 
    self.send_getOrderAttributeValue(orderId, attributeName)
5802 
    return self.recv_getOrderAttributeValue()
5803 
 
5804 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5805 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5806 
    args = getOrderAttributeValue_args()
5807 
    args.orderId = orderId
5808 
    args.attributeName = attributeName
5809 
    args.write(self._oprot)
5810 
    self._oprot.writeMessageEnd()
5811 
    self._oprot.trans.flush()
5812 
 
5813 
  def recv_getOrderAttributeValue(self, ):
5814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5815 
    if mtype == TMessageType.EXCEPTION:
5816 
      x = TApplicationException()
5817 
      x.read(self._iprot)
5818 
      self._iprot.readMessageEnd()
5819 
      raise x
5820 
    result = getOrderAttributeValue_result()
5821 
    result.read(self._iprot)
5822 
    self._iprot.readMessageEnd()
5823 
    if result.success is not None:
5824 
      return result.success
5825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5826 
 
6019 rajveer 5827 
  def changeJacketNumber(self, orderId, jacketNumber):
5828 
    """
5829 
    Parameters:
5830 
     - orderId
5831 
     - jacketNumber
5832 
    """
5833 
    self.send_changeJacketNumber(orderId, jacketNumber)
5834 
    return self.recv_changeJacketNumber()
5835 
 
5836 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5837 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5838 
    args = changeJacketNumber_args()
5839 
    args.orderId = orderId
5840 
    args.jacketNumber = jacketNumber
5841 
    args.write(self._oprot)
5842 
    self._oprot.writeMessageEnd()
5843 
    self._oprot.trans.flush()
5844 
 
5845 
  def recv_changeJacketNumber(self, ):
5846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5847 
    if mtype == TMessageType.EXCEPTION:
5848 
      x = TApplicationException()
5849 
      x.read(self._iprot)
5850 
      self._iprot.readMessageEnd()
5851 
      raise x
5852 
    result = changeJacketNumber_result()
5853 
    result.read(self._iprot)
5854 
    self._iprot.readMessageEnd()
5855 
    if result.success is not None:
5856 
      return result.success
5857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5858 
 
5859 
  def markOrderAsRtoInTransit(self, orderId):
5860 
    """
5861 
    Parameters:
5862 
     - orderId
5863 
    """
5864 
    self.send_markOrderAsRtoInTransit(orderId)
5865 
    return self.recv_markOrderAsRtoInTransit()
5866 
 
5867 
  def send_markOrderAsRtoInTransit(self, orderId):
5868 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5869 
    args = markOrderAsRtoInTransit_args()
5870 
    args.orderId = orderId
5871 
    args.write(self._oprot)
5872 
    self._oprot.writeMessageEnd()
5873 
    self._oprot.trans.flush()
5874 
 
5875 
  def recv_markOrderAsRtoInTransit(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 = markOrderAsRtoInTransit_result()
5883 
    result.read(self._iprot)
5884 
    self._iprot.readMessageEnd()
5885 
    if result.success is not None:
5886 
      return result.success
5887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5888 
 
5593 mandeep.dh 5889 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5890 
    """
5891 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5892 
    invoked while scanning IN of items.
5553 rajveer 5893 
 
5593 mandeep.dh 5894 
    Parameters:
5895 
     - itemId
5896 
     - quantity
5897 
     - fulfilmentWarehouseId
5898 
     - billingWarehouseId
5899 
    """
5900 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5901 
    self.recv_acceptOrderForItem()
5902 
 
5903 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5904 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5905 
    args = acceptOrderForItem_args()
5906 
    args.itemId = itemId
5907 
    args.quantity = quantity
5908 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5909 
    args.billingWarehouseId = billingWarehouseId
5910 
    args.write(self._oprot)
5911 
    self._oprot.writeMessageEnd()
5912 
    self._oprot.trans.flush()
5913 
 
5914 
  def recv_acceptOrderForItem(self, ):
5915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5916 
    if mtype == TMessageType.EXCEPTION:
5917 
      x = TApplicationException()
5918 
      x.read(self._iprot)
5919 
      self._iprot.readMessageEnd()
5920 
      raise x
5921 
    result = acceptOrderForItem_result()
5922 
    result.read(self._iprot)
5923 
    self._iprot.readMessageEnd()
5924 
    return
5925 
 
6000 mandeep.dh 5926 
  def createRechargeOrder(self, rechargeOrder):
5927 
    """
5928 
    Parameters:
5929 
     - rechargeOrder
5930 
    """
5931 
    self.send_createRechargeOrder(rechargeOrder)
5932 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5933 
 
6000 mandeep.dh 5934 
  def send_createRechargeOrder(self, rechargeOrder):
5935 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5936 
    args = createRechargeOrder_args()
5937 
    args.rechargeOrder = rechargeOrder
5938 
    args.write(self._oprot)
5939 
    self._oprot.writeMessageEnd()
5940 
    self._oprot.trans.flush()
5941 
 
5942 
  def recv_createRechargeOrder(self, ):
5943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5944 
    if mtype == TMessageType.EXCEPTION:
5945 
      x = TApplicationException()
5946 
      x.read(self._iprot)
5947 
      self._iprot.readMessageEnd()
5948 
      raise x
5949 
    result = createRechargeOrder_result()
5950 
    result.read(self._iprot)
5951 
    self._iprot.readMessageEnd()
5952 
    if result.success is not None:
5953 
      return result.success
5954 
    if result.ex is not None:
5955 
      raise result.ex
5956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5957 
 
6031 rajveer 5958 
  def getRechargeOrder(self, rechargeRrderId):
5959 
    """
5960 
    Parameters:
5961 
     - rechargeRrderId
5962 
    """
5963 
    self.send_getRechargeOrder(rechargeRrderId)
5964 
    return self.recv_getRechargeOrder()
5965 
 
5966 
  def send_getRechargeOrder(self, rechargeRrderId):
5967 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5968 
    args = getRechargeOrder_args()
5969 
    args.rechargeRrderId = rechargeRrderId
5970 
    args.write(self._oprot)
5971 
    self._oprot.writeMessageEnd()
5972 
    self._oprot.trans.flush()
5973 
 
5974 
  def recv_getRechargeOrder(self, ):
5975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5976 
    if mtype == TMessageType.EXCEPTION:
5977 
      x = TApplicationException()
5978 
      x.read(self._iprot)
5979 
      self._iprot.readMessageEnd()
5980 
      raise x
5981 
    result = getRechargeOrder_result()
5982 
    result.read(self._iprot)
5983 
    self._iprot.readMessageEnd()
5984 
    if result.success is not None:
5985 
      return result.success
5986 
    if result.ex is not None:
5987 
      raise result.ex
5988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5989 
 
5990 
  def getRechargeOrders(self, userId):
5991 
    """
5992 
    Parameters:
5993 
     - userId
5994 
    """
5995 
    self.send_getRechargeOrders(userId)
5996 
    return self.recv_getRechargeOrders()
5997 
 
5998 
  def send_getRechargeOrders(self, userId):
5999 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6000 
    args = getRechargeOrders_args()
6001 
    args.userId = userId
6002 
    args.write(self._oprot)
6003 
    self._oprot.writeMessageEnd()
6004 
    self._oprot.trans.flush()
6005 
 
6006 
  def recv_getRechargeOrders(self, ):
6007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6008 
    if mtype == TMessageType.EXCEPTION:
6009 
      x = TApplicationException()
6010 
      x.read(self._iprot)
6011 
      self._iprot.readMessageEnd()
6012 
      raise x
6013 
    result = getRechargeOrders_result()
6014 
    result.read(self._iprot)
6015 
    self._iprot.readMessageEnd()
6016 
    if result.success is not None:
6017 
      return result.success
6018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6019 
 
6000 mandeep.dh 6020 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6021 
    """
6022 
    Parameters:
6023 
     - rechargeOrderId
6024 
     - rechargeOrderStatus
6025 
    """
6026 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6027 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6028 
 
6029 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6030 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6031 
    args = updateRechargeOrderStatus_args()
6032 
    args.rechargeOrderId = rechargeOrderId
6033 
    args.rechargeOrderStatus = rechargeOrderStatus
6034 
    args.write(self._oprot)
6035 
    self._oprot.writeMessageEnd()
6036 
    self._oprot.trans.flush()
6037 
 
6038 
  def recv_updateRechargeOrderStatus(self, ):
6039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6040 
    if mtype == TMessageType.EXCEPTION:
6041 
      x = TApplicationException()
6042 
      x.read(self._iprot)
6043 
      self._iprot.readMessageEnd()
6044 
      raise x
6045 
    result = updateRechargeOrderStatus_result()
6046 
    result.read(self._iprot)
6047 
    self._iprot.readMessageEnd()
6031 rajveer 6048 
    if result.success is not None:
6049 
      return result.success
6000 mandeep.dh 6050 
    if result.ex is not None:
6051 
      raise result.ex
6031 rajveer 6052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6053 
 
6031 rajveer 6054 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6055 
    """
6056 
    Parameters:
6031 rajveer 6057 
     - rechargeOrderId
6000 mandeep.dh 6058 
    """
6031 rajveer 6059 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6060 
    return self.recv_activateRechargeTxn()
6061 
 
6031 rajveer 6062 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6063 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6064 
    args = activateRechargeTxn_args()
6031 rajveer 6065 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6066 
    args.write(self._oprot)
6067 
    self._oprot.writeMessageEnd()
6068 
    self._oprot.trans.flush()
6069 
 
6070 
  def recv_activateRechargeTxn(self, ):
6071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6072 
    if mtype == TMessageType.EXCEPTION:
6073 
      x = TApplicationException()
6074 
      x.read(self._iprot)
6075 
      self._iprot.readMessageEnd()
6076 
      raise x
6077 
    result = activateRechargeTxn_result()
6078 
    result.read(self._iprot)
6079 
    self._iprot.readMessageEnd()
6080 
    if result.success is not None:
6081 
      return result.success
6082 
    if result.ex is not None:
6083 
      raise result.ex
6084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6085 
 
6031 rajveer 6086 
  def getUserWallet(self, userId):
6000 mandeep.dh 6087 
    """
6088 
    Parameters:
6031 rajveer 6089 
     - userId
6000 mandeep.dh 6090 
    """
6031 rajveer 6091 
    self.send_getUserWallet(userId)
6092 
    return self.recv_getUserWallet()
6000 mandeep.dh 6093 
 
6031 rajveer 6094 
  def send_getUserWallet(self, userId):
6095 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6096 
    args = getUserWallet_args()
6097 
    args.userId = userId
6000 mandeep.dh 6098 
    args.write(self._oprot)
6099 
    self._oprot.writeMessageEnd()
6100 
    self._oprot.trans.flush()
6101 
 
6031 rajveer 6102 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6104 
    if mtype == TMessageType.EXCEPTION:
6105 
      x = TApplicationException()
6106 
      x.read(self._iprot)
6107 
      self._iprot.readMessageEnd()
6108 
      raise x
6031 rajveer 6109 
    result = getUserWallet_result()
6000 mandeep.dh 6110 
    result.read(self._iprot)
6111 
    self._iprot.readMessageEnd()
6112 
    if result.success is not None:
6113 
      return result.success
6031 rajveer 6114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6115 
 
6031 rajveer 6116 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6117 
    """
6118 
    Parameters:
6031 rajveer 6119 
     - userId
6000 mandeep.dh 6120 
    """
6031 rajveer 6121 
    self.send_getUserWalletHistory(userId)
6122 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6123 
 
6031 rajveer 6124 
  def send_getUserWalletHistory(self, userId):
6125 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6126 
    args = getUserWalletHistory_args()
6127 
    args.userId = userId
6000 mandeep.dh 6128 
    args.write(self._oprot)
6129 
    self._oprot.writeMessageEnd()
6130 
    self._oprot.trans.flush()
6131 
 
6031 rajveer 6132 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6134 
    if mtype == TMessageType.EXCEPTION:
6135 
      x = TApplicationException()
6136 
      x.read(self._iprot)
6137 
      self._iprot.readMessageEnd()
6138 
      raise x
6031 rajveer 6139 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6140 
    result.read(self._iprot)
6141 
    self._iprot.readMessageEnd()
6142 
    if result.success is not None:
6143 
      return result.success
6031 rajveer 6144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6145 
 
6050 anupam.sin 6146 
  def getRechargeOrdersForTransaction(self, txnId):
6147 
    """
6148 
    Returns a recharge order for a given transactionId
6149 
 
6150 
    Parameters:
6151 
     - txnId
6152 
    """
6153 
    self.send_getRechargeOrdersForTransaction(txnId)
6154 
    return self.recv_getRechargeOrdersForTransaction()
6155 
 
6156 
  def send_getRechargeOrdersForTransaction(self, txnId):
6157 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6158 
    args = getRechargeOrdersForTransaction_args()
6159 
    args.txnId = txnId
6160 
    args.write(self._oprot)
6161 
    self._oprot.writeMessageEnd()
6162 
    self._oprot.trans.flush()
6163 
 
6164 
  def recv_getRechargeOrdersForTransaction(self, ):
6165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6166 
    if mtype == TMessageType.EXCEPTION:
6167 
      x = TApplicationException()
6168 
      x.read(self._iprot)
6169 
      self._iprot.readMessageEnd()
6170 
      raise x
6171 
    result = getRechargeOrdersForTransaction_result()
6172 
    result.read(self._iprot)
6173 
    self._iprot.readMessageEnd()
6174 
    if result.success is not None:
6175 
      return result.success
6176 
    if result.ex is not None:
6177 
      raise result.ex
6178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6179 
 
6206 rajveer 6180 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6181 
    """
6182 
    Parameters:
6183 
     - rechargeType
6206 rajveer 6184 
     - onlyActive
6048 rajveer 6185 
    """
6206 rajveer 6186 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6187 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6188 
 
6206 rajveer 6189 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6190 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6191 
    args = getServiceProviders_args()
6192 
    args.rechargeType = rechargeType
6206 rajveer 6193 
    args.onlyActive = onlyActive
6048 rajveer 6194 
    args.write(self._oprot)
6195 
    self._oprot.writeMessageEnd()
6196 
    self._oprot.trans.flush()
6197 
 
6198 
  def recv_getServiceProviders(self, ):
6199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6200 
    if mtype == TMessageType.EXCEPTION:
6201 
      x = TApplicationException()
6202 
      x.read(self._iprot)
6203 
      self._iprot.readMessageEnd()
6204 
      raise x
6205 
    result = getServiceProviders_result()
6206 
    result.read(self._iprot)
6207 
    self._iprot.readMessageEnd()
6208 
    if result.success is not None:
6209 
      return result.success
6210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6211 
 
6049 rajveer 6212 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6213 
    """
6214 
    Parameters:
6049 rajveer 6215 
     - rechargeType
6048 rajveer 6216 
     - deviceNumber
6217 
    """
6049 rajveer 6218 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6219 
    return self.recv_getServiceProviderForDevice()
6220 
 
6049 rajveer 6221 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6222 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6223 
    args = getServiceProviderForDevice_args()
6049 rajveer 6224 
    args.rechargeType = rechargeType
6048 rajveer 6225 
    args.deviceNumber = deviceNumber
6226 
    args.write(self._oprot)
6227 
    self._oprot.writeMessageEnd()
6228 
    self._oprot.trans.flush()
6229 
 
6230 
  def recv_getServiceProviderForDevice(self, ):
6231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6232 
    if mtype == TMessageType.EXCEPTION:
6233 
      x = TApplicationException()
6234 
      x.read(self._iprot)
6235 
      self._iprot.readMessageEnd()
6236 
      raise x
6237 
    result = getServiceProviderForDevice_result()
6238 
    result.read(self._iprot)
6239 
    self._iprot.readMessageEnd()
6240 
    if result.success is not None:
6241 
      return result.success
6242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6243 
 
6591 anupam.sin 6244 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6245 
    """
6246 
    Parameters:
6247 
     - rechargeType
6248 
     - deviceNumber
6307 anupam.sin 6249 
     - userSelectedProviderId
6591 anupam.sin 6250 
     - clientAddress
6269 rajveer 6251 
    """
6591 anupam.sin 6252 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6253 
    return self.recv_validateRecharge()
6254 
 
6591 anupam.sin 6255 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6256 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6257 
    args = validateRecharge_args()
6258 
    args.rechargeType = rechargeType
6259 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6260 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6261 
    args.clientAddress = clientAddress
6269 rajveer 6262 
    args.write(self._oprot)
6263 
    self._oprot.writeMessageEnd()
6264 
    self._oprot.trans.flush()
6265 
 
6266 
  def recv_validateRecharge(self, ):
6267 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6268 
    if mtype == TMessageType.EXCEPTION:
6269 
      x = TApplicationException()
6270 
      x.read(self._iprot)
6271 
      self._iprot.readMessageEnd()
6272 
      raise x
6273 
    result = validateRecharge_result()
6274 
    result.read(self._iprot)
6275 
    self._iprot.readMessageEnd()
6276 
    if result.success is not None:
6277 
      return result.success
6278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6279 
 
6094 rajveer 6280 
  def getRechargeOrdersForDevice(self, deviceNumber):
6281 
    """
6282 
    Parameters:
6283 
     - deviceNumber
6284 
    """
6285 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6286 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6287 
 
6094 rajveer 6288 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6289 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6290 
    args = getRechargeOrdersForDevice_args()
6291 
    args.deviceNumber = deviceNumber
6292 
    args.write(self._oprot)
6293 
    self._oprot.writeMessageEnd()
6294 
    self._oprot.trans.flush()
6295 
 
6296 
  def recv_getRechargeOrdersForDevice(self, ):
6297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6298 
    if mtype == TMessageType.EXCEPTION:
6299 
      x = TApplicationException()
6300 
      x.read(self._iprot)
6301 
      self._iprot.readMessageEnd()
6302 
      raise x
6303 
    result = getRechargeOrdersForDevice_result()
6304 
    result.read(self._iprot)
6305 
    self._iprot.readMessageEnd()
6306 
    if result.success is not None:
6307 
      return result.success
6308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6309 
 
6310 
  def addAmountToWallet(self, userId, orderId, amount):
6311 
    """
6312 
    Parameters:
6313 
     - userId
6314 
     - orderId
6315 
     - amount
6316 
    """
6317 
    self.send_addAmountToWallet(userId, orderId, amount)
6318 
    self.recv_addAmountToWallet()
6319 
 
6320 
  def send_addAmountToWallet(self, userId, orderId, amount):
6321 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6322 
    args = addAmountToWallet_args()
6323 
    args.userId = userId
6324 
    args.orderId = orderId
6325 
    args.amount = amount
6326 
    args.write(self._oprot)
6327 
    self._oprot.writeMessageEnd()
6328 
    self._oprot.trans.flush()
6329 
 
6330 
  def recv_addAmountToWallet(self, ):
6331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6332 
    if mtype == TMessageType.EXCEPTION:
6333 
      x = TApplicationException()
6334 
      x.read(self._iprot)
6335 
      self._iprot.readMessageEnd()
6336 
      raise x
6337 
    result = addAmountToWallet_result()
6338 
    result.read(self._iprot)
6339 
    self._iprot.readMessageEnd()
6340 
    return
6341 
 
6188 rajveer 6342 
  def getRechargeStatistics(self, ):
6343 
    self.send_getRechargeStatistics()
6344 
    return self.recv_getRechargeStatistics()
6345 
 
6346 
  def send_getRechargeStatistics(self, ):
6347 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6348 
    args = getRechargeStatistics_args()
6349 
    args.write(self._oprot)
6350 
    self._oprot.writeMessageEnd()
6351 
    self._oprot.trans.flush()
6352 
 
6353 
  def recv_getRechargeStatistics(self, ):
6354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6355 
    if mtype == TMessageType.EXCEPTION:
6356 
      x = TApplicationException()
6357 
      x.read(self._iprot)
6358 
      self._iprot.readMessageEnd()
6359 
      raise x
6360 
    result = getRechargeStatistics_result()
6361 
    result.read(self._iprot)
6362 
    self._iprot.readMessageEnd()
6363 
    if result.success is not None:
6364 
      return result.success
6365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6366 
 
6154 rajveer 6367 
  def getRechargeOrdersForStatus(self, status):
6368 
    """
6369 
    Parameters:
6370 
     - status
6371 
    """
6372 
    self.send_getRechargeOrdersForStatus(status)
6373 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6374 
 
6154 rajveer 6375 
  def send_getRechargeOrdersForStatus(self, status):
6376 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6377 
    args = getRechargeOrdersForStatus_args()
6378 
    args.status = status
6379 
    args.write(self._oprot)
6380 
    self._oprot.writeMessageEnd()
6381 
    self._oprot.trans.flush()
6382 
 
6383 
  def recv_getRechargeOrdersForStatus(self, ):
6384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6385 
    if mtype == TMessageType.EXCEPTION:
6386 
      x = TApplicationException()
6387 
      x.read(self._iprot)
6388 
      self._iprot.readMessageEnd()
6389 
      raise x
6390 
    result = getRechargeOrdersForStatus_result()
6391 
    result.read(self._iprot)
6392 
    self._iprot.readMessageEnd()
6393 
    if result.success is not None:
6394 
      return result.success
6395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6396 
 
6159 rajveer 6397 
  def getPlansForOperator(self, operatorId):
6398 
    """
6399 
    Parameters:
6400 
     - operatorId
6401 
    """
6402 
    self.send_getPlansForOperator(operatorId)
6403 
    return self.recv_getPlansForOperator()
6154 rajveer 6404 
 
6159 rajveer 6405 
  def send_getPlansForOperator(self, operatorId):
6406 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6407 
    args = getPlansForOperator_args()
6408 
    args.operatorId = operatorId
6409 
    args.write(self._oprot)
6410 
    self._oprot.writeMessageEnd()
6411 
    self._oprot.trans.flush()
6412 
 
6413 
  def recv_getPlansForOperator(self, ):
6414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6415 
    if mtype == TMessageType.EXCEPTION:
6416 
      x = TApplicationException()
6417 
      x.read(self._iprot)
6418 
      self._iprot.readMessageEnd()
6419 
      raise x
6420 
    result = getPlansForOperator_result()
6421 
    result.read(self._iprot)
6422 
    self._iprot.readMessageEnd()
6423 
    if result.success is not None:
6424 
      return result.success
6425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6426 
 
6307 anupam.sin 6427 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6428 
    """
6429 
    Returns denominations for a given operator and circle
6159 rajveer 6430 
 
6289 anupam.sin 6431 
    Parameters:
6432 
     - operatorId
6307 anupam.sin 6433 
     - circleCode
6289 anupam.sin 6434 
     - denominationType
6435 
    """
6307 anupam.sin 6436 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6437 
    return self.recv_getRechargeDenominations()
6438 
 
6307 anupam.sin 6439 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6440 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6441 
    args = getRechargeDenominations_args()
6442 
    args.operatorId = operatorId
6307 anupam.sin 6443 
    args.circleCode = circleCode
6289 anupam.sin 6444 
    args.denominationType = denominationType
6445 
    args.write(self._oprot)
6446 
    self._oprot.writeMessageEnd()
6447 
    self._oprot.trans.flush()
6448 
 
6449 
  def recv_getRechargeDenominations(self, ):
6450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6451 
    if mtype == TMessageType.EXCEPTION:
6452 
      x = TApplicationException()
6453 
      x.read(self._iprot)
6454 
      self._iprot.readMessageEnd()
6455 
      raise x
6456 
    result = getRechargeDenominations_result()
6457 
    result.read(self._iprot)
6458 
    self._iprot.readMessageEnd()
6459 
    if result.success is not None:
6460 
      return result.success
6461 
    if result.ex is not None:
6462 
      raise result.ex
6463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6464 
 
6371 rajveer 6465 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6466 
    """
6467 
    Parameters:
6468 
     - operatorId
6469 
     - circleId
6470 
     - isAvailable
6471 
    """
6472 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6473 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6474 
 
6371 rajveer 6475 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6476 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6477 
    args = updateAvailabilityStatus_args()
6478 
    args.operatorId = operatorId
6479 
    args.circleId = circleId
6480 
    args.isAvailable = isAvailable
6481 
    args.write(self._oprot)
6482 
    self._oprot.writeMessageEnd()
6483 
    self._oprot.trans.flush()
6484 
 
6485 
  def recv_updateAvailabilityStatus(self, ):
6486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6487 
    if mtype == TMessageType.EXCEPTION:
6488 
      x = TApplicationException()
6489 
      x.read(self._iprot)
6490 
      self._iprot.readMessageEnd()
6491 
      raise x
6492 
    result = updateAvailabilityStatus_result()
6493 
    result.read(self._iprot)
6494 
    self._iprot.readMessageEnd()
6495 
    return
6496 
 
6389 rajveer 6497 
  def getAvailableEmiSchemes(self, ):
6498 
    self.send_getAvailableEmiSchemes()
6499 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6500 
 
6389 rajveer 6501 
  def send_getAvailableEmiSchemes(self, ):
6502 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6503 
    args = getAvailableEmiSchemes_args()
6504 
    args.write(self._oprot)
6505 
    self._oprot.writeMessageEnd()
6506 
    self._oprot.trans.flush()
6507 
 
6508 
  def recv_getAvailableEmiSchemes(self, ):
6509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6510 
    if mtype == TMessageType.EXCEPTION:
6511 
      x = TApplicationException()
6512 
      x.read(self._iprot)
6513 
      self._iprot.readMessageEnd()
6514 
      raise x
6515 
    result = getAvailableEmiSchemes_result()
6516 
    result.read(self._iprot)
6517 
    self._iprot.readMessageEnd()
6518 
    if result.success is not None:
6519 
      return result.success
6520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6521 
 
6522 
  def getMiscCharges(self, transactionId):
6523 
    """
6524 
    Parameters:
6525 
     - transactionId
6526 
    """
6527 
    self.send_getMiscCharges(transactionId)
6528 
    return self.recv_getMiscCharges()
6529 
 
6530 
  def send_getMiscCharges(self, transactionId):
6531 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6532 
    args = getMiscCharges_args()
6533 
    args.transactionId = transactionId
6534 
    args.write(self._oprot)
6535 
    self._oprot.writeMessageEnd()
6536 
    self._oprot.trans.flush()
6537 
 
6538 
  def recv_getMiscCharges(self, ):
6539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6540 
    if mtype == TMessageType.EXCEPTION:
6541 
      x = TApplicationException()
6542 
      x.read(self._iprot)
6543 
      self._iprot.readMessageEnd()
6544 
      raise x
6545 
    result = getMiscCharges_result()
6546 
    result.read(self._iprot)
6547 
    self._iprot.readMessageEnd()
6548 
    if result.success is not None:
6549 
      return result.success
6550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6551 
 
6507 anupam.sin 6552 
  def refundRechargeOrder(self, rechargeOrderId):
6553 
    """
6554 
    Parameters:
6555 
     - rechargeOrderId
6556 
    """
6557 
    self.send_refundRechargeOrder(rechargeOrderId)
6558 
    return self.recv_refundRechargeOrder()
6389 rajveer 6559 
 
6507 anupam.sin 6560 
  def send_refundRechargeOrder(self, rechargeOrderId):
6561 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6562 
    args = refundRechargeOrder_args()
6563 
    args.rechargeOrderId = rechargeOrderId
6564 
    args.write(self._oprot)
6565 
    self._oprot.writeMessageEnd()
6566 
    self._oprot.trans.flush()
6567 
 
6568 
  def recv_refundRechargeOrder(self, ):
6569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6570 
    if mtype == TMessageType.EXCEPTION:
6571 
      x = TApplicationException()
6572 
      x.read(self._iprot)
6573 
      self._iprot.readMessageEnd()
6574 
      raise x
6575 
    result = refundRechargeOrder_result()
6576 
    result.read(self._iprot)
6577 
    self._iprot.readMessageEnd()
6578 
    if result.success is not None:
6579 
      return result.success
6580 
    if result.ex is not None:
6581 
      raise result.ex
6582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6583 
 
6821 amar.kumar 6584 
  def getPhysicalOrders(self, fromDate, toDate):
6585 
    """
6586 
    Parameters:
6587 
     - fromDate
6588 
     - toDate
6589 
    """
6590 
    self.send_getPhysicalOrders(fromDate, toDate)
6591 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6592 
 
6821 amar.kumar 6593 
  def send_getPhysicalOrders(self, fromDate, toDate):
6594 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6595 
    args = getPhysicalOrders_args()
6596 
    args.fromDate = fromDate
6597 
    args.toDate = toDate
6598 
    args.write(self._oprot)
6599 
    self._oprot.writeMessageEnd()
6600 
    self._oprot.trans.flush()
6601 
 
6602 
  def recv_getPhysicalOrders(self, ):
6603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6604 
    if mtype == TMessageType.EXCEPTION:
6605 
      x = TApplicationException()
6606 
      x.read(self._iprot)
6607 
      self._iprot.readMessageEnd()
6608 
      raise x
6609 
    result = getPhysicalOrders_result()
6610 
    result.read(self._iprot)
6611 
    self._iprot.readMessageEnd()
6612 
    if result.success is not None:
6613 
      return result.success
6614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6615 
 
6906 rajveer 6616 
  def getDocument(self, docType, docSource):
6617 
    """
6618 
    Parameters:
6619 
     - docType
6620 
     - docSource
6621 
    """
6622 
    self.send_getDocument(docType, docSource)
6623 
    return self.recv_getDocument()
6821 amar.kumar 6624 
 
6906 rajveer 6625 
  def send_getDocument(self, docType, docSource):
6626 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6627 
    args = getDocument_args()
6628 
    args.docType = docType
6629 
    args.docSource = docSource
6630 
    args.write(self._oprot)
6631 
    self._oprot.writeMessageEnd()
6632 
    self._oprot.trans.flush()
6633 
 
6634 
  def recv_getDocument(self, ):
6635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6636 
    if mtype == TMessageType.EXCEPTION:
6637 
      x = TApplicationException()
6638 
      x.read(self._iprot)
6639 
      self._iprot.readMessageEnd()
6640 
      raise x
6641 
    result = getDocument_result()
6642 
    result.read(self._iprot)
6643 
    self._iprot.readMessageEnd()
6644 
    if result.success is not None:
6645 
      return result.success
6646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6647 
 
6985 anupam.sin 6648 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6649 
    """
6650 
    Parameters:
6651 
     - orderId
6652 
     - line1
6653 
     - line2
6654 
     - city
6655 
     - state
6656 
     - pin
6657 
    """
6658 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6659 
    return self.recv_changeShippingAddress()
6906 rajveer 6660 
 
6985 anupam.sin 6661 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6662 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6663 
    args = changeShippingAddress_args()
6664 
    args.orderId = orderId
6665 
    args.line1 = line1
6666 
    args.line2 = line2
6667 
    args.city = city
6668 
    args.state = state
6669 
    args.pin = pin
6670 
    args.write(self._oprot)
6671 
    self._oprot.writeMessageEnd()
6672 
    self._oprot.trans.flush()
6673 
 
6674 
  def recv_changeShippingAddress(self, ):
6675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6676 
    if mtype == TMessageType.EXCEPTION:
6677 
      x = TApplicationException()
6678 
      x.read(self._iprot)
6679 
      self._iprot.readMessageEnd()
6680 
      raise x
6681 
    result = changeShippingAddress_result()
6682 
    result.read(self._iprot)
6683 
    self._iprot.readMessageEnd()
6684 
    if result.success is not None:
6685 
      return result.success
6686 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6687 
 
6988 rajveer 6688 
  def retrieveInvoice(self, orderId):
6689 
    """
6690 
    Parameters:
6691 
     - orderId
6692 
    """
6693 
    self.send_retrieveInvoice(orderId)
6694 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6695 
 
6988 rajveer 6696 
  def send_retrieveInvoice(self, orderId):
6697 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6698 
    args = retrieveInvoice_args()
6699 
    args.orderId = orderId
6700 
    args.write(self._oprot)
6701 
    self._oprot.writeMessageEnd()
6702 
    self._oprot.trans.flush()
6703 
 
6704 
  def recv_retrieveInvoice(self, ):
6705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6706 
    if mtype == TMessageType.EXCEPTION:
6707 
      x = TApplicationException()
6708 
      x.read(self._iprot)
6709 
      self._iprot.readMessageEnd()
6710 
      raise x
6711 
    result = retrieveInvoice_result()
6712 
    result.read(self._iprot)
6713 
    self._iprot.readMessageEnd()
6714 
    if result.success is not None:
6715 
      return result.success
6716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6717 
 
6718 
 
3376 rajveer 6719 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6720 
  def __init__(self, handler):
3376 rajveer 6721 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6722 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6723 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6724 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6725 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6726 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6727 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6728 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6729 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6730 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6731 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6732 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6733 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6734 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6735 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6736 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6737 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6738 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6739 
    self._processMap["createOrder"] = Processor.process_createOrder
6740 
    self._processMap["getOrder"] = Processor.process_getOrder
6741 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6742 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6743 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6744 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6745 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6746 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6747 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6748 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6749 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6750 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6751 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6752 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6753 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6754 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6755 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6756 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6757 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6758 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6759 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6760 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6761 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6762 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6763 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6764 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6765 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6766 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6767 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6768 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6769 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6770 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6771 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6772 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6773 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6774 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6775 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6776 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6777 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6778 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6779 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6780 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6781 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6782 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6783 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6784 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6785 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6786 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6787 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6788 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6789 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6790 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6791 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6792 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6793 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6794 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6795 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6796 
    self._processMap["changeItem"] = Processor.process_changeItem
6797 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6798 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6799 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6800 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6801 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6802 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6803 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6804 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6805 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6806 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6807 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6808 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6809 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6810 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6811 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6812 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6813 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6814 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6815 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6816 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6817 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6818 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6819 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6820 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6821 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6822 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6823 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6824 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6825 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6826 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6827 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6828 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6829 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6830 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6831 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6832 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6833 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6834 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6835 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6836 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6837 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6838 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6839 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6840 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6841 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6842 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6843 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6844 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6845 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6846 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6847 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6848 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6849 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6850 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6851 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6852 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6853 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6854 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6855 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6856 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6857 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6858 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6859 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6860 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6861 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6862 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6863 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6864 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6865 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6866 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6867 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6868 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6869 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6870 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 6871 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 6872 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 6873 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
94 ashish 6874 
 
6875 
  def process(self, iprot, oprot):
6876 
    (name, type, seqid) = iprot.readMessageBegin()
6877 
    if name not in self._processMap:
6878 
      iprot.skip(TType.STRUCT)
6879 
      iprot.readMessageEnd()
6880 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6881 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6882 
      x.write(oprot)
6883 
      oprot.writeMessageEnd()
6884 
      oprot.trans.flush()
6885 
      return
6886 
    else:
6887 
      self._processMap[name](self, seqid, iprot, oprot)
6888 
    return True
6889 
 
6890 
  def process_createTransaction(self, seqid, iprot, oprot):
6891 
    args = createTransaction_args()
6892 
    args.read(iprot)
6893 
    iprot.readMessageEnd()
6894 
    result = createTransaction_result()
6895 
    try:
132 ashish 6896 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6897 
    except TransactionServiceException, ex:
6898 
      result.ex = ex
6899 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6900 
    result.write(oprot)
6901 
    oprot.writeMessageEnd()
6902 
    oprot.trans.flush()
6903 
 
6904 
  def process_getTransaction(self, seqid, iprot, oprot):
6905 
    args = getTransaction_args()
6906 
    args.read(iprot)
6907 
    iprot.readMessageEnd()
6908 
    result = getTransaction_result()
6909 
    try:
6910 
      result.success = self._handler.getTransaction(args.id)
6911 
    except TransactionServiceException, ex:
6912 
      result.ex = ex
6913 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6914 
    result.write(oprot)
6915 
    oprot.writeMessageEnd()
6916 
    oprot.trans.flush()
6917 
 
6918 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6919 
    args = getTransactionsForCustomer_args()
6920 
    args.read(iprot)
6921 
    iprot.readMessageEnd()
6922 
    result = getTransactionsForCustomer_result()
6923 
    try:
6924 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6925 
    except TransactionServiceException, ex:
6926 
      result.ex = ex
6927 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6928 
    result.write(oprot)
6929 
    oprot.writeMessageEnd()
6930 
    oprot.trans.flush()
6931 
 
132 ashish 6932 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6933 
    args = getTransactionsForShoppingCartId_args()
6934 
    args.read(iprot)
6935 
    iprot.readMessageEnd()
6936 
    result = getTransactionsForShoppingCartId_result()
6937 
    try:
6938 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6939 
    except TransactionServiceException, ex:
6940 
      result.ex = ex
6941 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6942 
    result.write(oprot)
6943 
    oprot.writeMessageEnd()
6944 
    oprot.trans.flush()
6945 
 
94 ashish 6946 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6947 
    args = getTransactionStatus_args()
6948 
    args.read(iprot)
6949 
    iprot.readMessageEnd()
6950 
    result = getTransactionStatus_result()
6951 
    try:
6952 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6953 
    except TransactionServiceException, ex:
6954 
      result.ex = ex
6955 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6956 
    result.write(oprot)
6957 
    oprot.writeMessageEnd()
6958 
    oprot.trans.flush()
6959 
 
6960 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6961 
    args = changeTransactionStatus_args()
6962 
    args.read(iprot)
6963 
    iprot.readMessageEnd()
6964 
    result = changeTransactionStatus_result()
6965 
    try:
5527 anupam.sin 6966 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6967 
    except TransactionServiceException, ex:
6968 
      result.ex = ex
6969 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6970 
    result.write(oprot)
6971 
    oprot.writeMessageEnd()
6972 
    oprot.trans.flush()
6973 
 
1398 varun.gupt 6974 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6975 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6976 
    args.read(iprot)
6977 
    iprot.readMessageEnd()
1398 varun.gupt 6978 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6979 
    try:
1398 varun.gupt 6980 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6981 
    except TransactionServiceException, ex:
6982 
      result.ex = ex
1398 varun.gupt 6983 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6984 
    result.write(oprot)
6985 
    oprot.writeMessageEnd()
6986 
    oprot.trans.flush()
6987 
 
483 rajveer 6988 
  def process_getAllOrders(self, seqid, iprot, oprot):
6989 
    args = getAllOrders_args()
94 ashish 6990 
    args.read(iprot)
6991 
    iprot.readMessageEnd()
483 rajveer 6992 
    result = getAllOrders_result()
94 ashish 6993 
    try:
4801 anupam.sin 6994 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6995 
    except TransactionServiceException, ex:
6996 
      result.ex = ex
483 rajveer 6997 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6998 
    result.write(oprot)
6999 
    oprot.writeMessageEnd()
7000 
    oprot.trans.flush()
7001 
 
4133 chandransh 7002 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7003 
    args = getOrdersInBatch_args()
7004 
    args.read(iprot)
7005 
    iprot.readMessageEnd()
7006 
    result = getOrdersInBatch_result()
7007 
    try:
7008 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7009 
    except TransactionServiceException, ex:
7010 
      result.ex = ex
7011 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7012 
    result.write(oprot)
7013 
    oprot.writeMessageEnd()
7014 
    oprot.trans.flush()
7015 
 
7016 
  def process_getOrderCount(self, seqid, iprot, oprot):
7017 
    args = getOrderCount_args()
7018 
    args.read(iprot)
7019 
    iprot.readMessageEnd()
7020 
    result = getOrderCount_result()
7021 
    try:
7022 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7023 
    except TransactionServiceException, ex:
7024 
      result.ex = ex
7025 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7026 
    result.write(oprot)
7027 
    oprot.writeMessageEnd()
7028 
    oprot.trans.flush()
7029 
 
999 varun.gupt 7030 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7031 
    args = getOrdersByBillingDate_args()
7032 
    args.read(iprot)
7033 
    iprot.readMessageEnd()
7034 
    result = getOrdersByBillingDate_result()
7035 
    try:
7036 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7037 
    except TransactionServiceException, ex:
7038 
      result.ex = ex
7039 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7040 
    result.write(oprot)
7041 
    oprot.writeMessageEnd()
7042 
    oprot.trans.flush()
7043 
 
3427 chandransh 7044 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7045 
    args = getOrdersByShippingDate_args()
7046 
    args.read(iprot)
7047 
    iprot.readMessageEnd()
7048 
    result = getOrdersByShippingDate_result()
7049 
    try:
3451 chandransh 7050 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7051 
    except TransactionServiceException, ex:
7052 
      result.ex = ex
7053 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7054 
    result.write(oprot)
7055 
    oprot.writeMessageEnd()
7056 
    oprot.trans.flush()
7057 
 
1382 varun.gupt 7058 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7059 
    args = getReturnableOrdersForCustomer_args()
7060 
    args.read(iprot)
7061 
    iprot.readMessageEnd()
7062 
    result = getReturnableOrdersForCustomer_result()
7063 
    try:
7064 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7065 
    except TransactionServiceException, ex:
7066 
      result.ex = ex
7067 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7068 
    result.write(oprot)
7069 
    oprot.writeMessageEnd()
7070 
    oprot.trans.flush()
7071 
 
7072 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7073 
    args = getCancellableOrdersForCustomer_args()
7074 
    args.read(iprot)
7075 
    iprot.readMessageEnd()
7076 
    result = getCancellableOrdersForCustomer_result()
7077 
    try:
7078 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7079 
    except TransactionServiceException, ex:
7080 
      result.ex = ex
7081 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7082 
    result.write(oprot)
7083 
    oprot.writeMessageEnd()
7084 
    oprot.trans.flush()
7085 
 
483 rajveer 7086 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7087 
    args = changeOrderStatus_args()
94 ashish 7088 
    args.read(iprot)
7089 
    iprot.readMessageEnd()
483 rajveer 7090 
    result = changeOrderStatus_result()
94 ashish 7091 
    try:
483 rajveer 7092 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7093 
    except TransactionServiceException, ex:
7094 
      result.ex = ex
483 rajveer 7095 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7096 
    result.write(oprot)
7097 
    oprot.writeMessageEnd()
7098 
    oprot.trans.flush()
7099 
 
483 rajveer 7100 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7101 
    args = getOrdersForTransaction_args()
94 ashish 7102 
    args.read(iprot)
7103 
    iprot.readMessageEnd()
483 rajveer 7104 
    result = getOrdersForTransaction_result()
94 ashish 7105 
    try:
1528 ankur.sing 7106 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7107 
    except TransactionServiceException, ex:
7108 
      result.ex = ex
483 rajveer 7109 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7110 
    result.write(oprot)
7111 
    oprot.writeMessageEnd()
7112 
    oprot.trans.flush()
7113 
 
483 rajveer 7114 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7115 
    args = getOrdersForCustomer_args()
94 ashish 7116 
    args.read(iprot)
7117 
    iprot.readMessageEnd()
483 rajveer 7118 
    result = getOrdersForCustomer_result()
94 ashish 7119 
    try:
3014 chandransh 7120 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7121 
    except TransactionServiceException, ex:
7122 
      result.ex = ex
483 rajveer 7123 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7124 
    result.write(oprot)
7125 
    oprot.writeMessageEnd()
7126 
    oprot.trans.flush()
7127 
 
483 rajveer 7128 
  def process_createOrder(self, seqid, iprot, oprot):
7129 
    args = createOrder_args()
94 ashish 7130 
    args.read(iprot)
7131 
    iprot.readMessageEnd()
483 rajveer 7132 
    result = createOrder_result()
94 ashish 7133 
    try:
483 rajveer 7134 
      result.success = self._handler.createOrder(args.order)
94 ashish 7135 
    except TransactionServiceException, ex:
7136 
      result.ex = ex
483 rajveer 7137 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
7141 
 
483 rajveer 7142 
  def process_getOrder(self, seqid, iprot, oprot):
7143 
    args = getOrder_args()
94 ashish 7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
483 rajveer 7146 
    result = getOrder_result()
94 ashish 7147 
    try:
483 rajveer 7148 
      result.success = self._handler.getOrder(args.id)
94 ashish 7149 
    except TransactionServiceException, ex:
7150 
      result.ex = ex
483 rajveer 7151 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7152 
    result.write(oprot)
7153 
    oprot.writeMessageEnd()
7154 
    oprot.trans.flush()
7155 
 
483 rajveer 7156 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7157 
    args = getLineItemsForOrder_args()
94 ashish 7158 
    args.read(iprot)
7159 
    iprot.readMessageEnd()
483 rajveer 7160 
    result = getLineItemsForOrder_result()
94 ashish 7161 
    try:
483 rajveer 7162 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7163 
    except TransactionServiceException, ex:
7164 
      result.ex = ex
483 rajveer 7165 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7166 
    result.write(oprot)
7167 
    oprot.writeMessageEnd()
7168 
    oprot.trans.flush()
7169 
 
4999 phani.kuma 7170 
  def process_getOrderList(self, seqid, iprot, oprot):
7171 
    args = getOrderList_args()
7172 
    args.read(iprot)
7173 
    iprot.readMessageEnd()
7174 
    result = getOrderList_result()
7175 
    result.success = self._handler.getOrderList(args.order_ids)
7176 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7177 
    result.write(oprot)
7178 
    oprot.writeMessageEnd()
7179 
    oprot.trans.flush()
7180 
 
5386 phani.kuma 7181 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7182 
    args = getOrderListForVendor_args()
7183 
    args.read(iprot)
7184 
    iprot.readMessageEnd()
7185 
    result = getOrderListForVendor_result()
7186 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7187 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7188 
    result.write(oprot)
7189 
    oprot.writeMessageEnd()
7190 
    oprot.trans.flush()
7191 
 
1528 ankur.sing 7192 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7193 
    args = getOrderForCustomer_args()
7194 
    args.read(iprot)
7195 
    iprot.readMessageEnd()
7196 
    result = getOrderForCustomer_result()
7197 
    try:
7198 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7199 
    except TransactionServiceException, ex:
7200 
      result.ex = ex
7201 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7202 
    result.write(oprot)
7203 
    oprot.writeMessageEnd()
7204 
    oprot.trans.flush()
7205 
 
3064 chandransh 7206 
  def process_getAlerts(self, seqid, iprot, oprot):
7207 
    args = getAlerts_args()
7208 
    args.read(iprot)
7209 
    iprot.readMessageEnd()
7210 
    result = getAlerts_result()
4444 rajveer 7211 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7212 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7213 
    result.write(oprot)
7214 
    oprot.writeMessageEnd()
7215 
    oprot.trans.flush()
7216 
 
4394 rajveer 7217 
  def process_addAlert(self, seqid, iprot, oprot):
7218 
    args = addAlert_args()
3064 chandransh 7219 
    args.read(iprot)
7220 
    iprot.readMessageEnd()
4394 rajveer 7221 
    result = addAlert_result()
4444 rajveer 7222 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7223 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7224 
    result.write(oprot)
7225 
    oprot.writeMessageEnd()
7226 
    oprot.trans.flush()
7227 
 
4444 rajveer 7228 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7229 
    args = markAlertsAsSeen_args()
7230 
    args.read(iprot)
7231 
    iprot.readMessageEnd()
7232 
    result = markAlertsAsSeen_result()
7233 
    self._handler.markAlertsAsSeen(args.warehouseId)
7234 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7235 
    result.write(oprot)
7236 
    oprot.writeMessageEnd()
7237 
    oprot.trans.flush()
7238 
 
3064 chandransh 7239 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7240 
    args = getValidOrderCount_args()
7241 
    args.read(iprot)
7242 
    iprot.readMessageEnd()
7243 
    result = getValidOrderCount_result()
7244 
    result.success = self._handler.getValidOrderCount()
7245 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7246 
    result.write(oprot)
7247 
    oprot.writeMessageEnd()
7248 
    oprot.trans.flush()
7249 
 
7250 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7251 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7252 
    args.read(iprot)
7253 
    iprot.readMessageEnd()
7254 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7255 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7256 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7257 
    result.write(oprot)
7258 
    oprot.writeMessageEnd()
7259 
    oprot.trans.flush()
7260 
 
7261 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7262 
    args = getValidOrdersAmountRange_args()
7263 
    args.read(iprot)
7264 
    iprot.readMessageEnd()
7265 
    result = getValidOrdersAmountRange_result()
7266 
    result.success = self._handler.getValidOrdersAmountRange()
7267 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7268 
    result.write(oprot)
7269 
    oprot.writeMessageEnd()
7270 
    oprot.trans.flush()
7271 
 
7272 
  def process_getValidOrders(self, seqid, iprot, oprot):
7273 
    args = getValidOrders_args()
7274 
    args.read(iprot)
7275 
    iprot.readMessageEnd()
7276 
    result = getValidOrders_result()
5874 rajveer 7277 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7278 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7279 
    result.write(oprot)
7280 
    oprot.writeMessageEnd()
7281 
    oprot.trans.flush()
7282 
 
1220 chandransh 7283 
  def process_batchOrders(self, seqid, iprot, oprot):
7284 
    args = batchOrders_args()
7285 
    args.read(iprot)
7286 
    iprot.readMessageEnd()
7287 
    result = batchOrders_result()
7288 
    try:
7289 
      result.success = self._handler.batchOrders(args.warehouseId)
7290 
    except TransactionServiceException, ex:
7291 
      result.ex = ex
7292 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7293 
    result.write(oprot)
7294 
    oprot.writeMessageEnd()
7295 
    oprot.trans.flush()
7296 
 
1208 chandransh 7297 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7298 
    args = markOrderAsOutOfStock_args()
7299 
    args.read(iprot)
7300 
    iprot.readMessageEnd()
7301 
    result = markOrderAsOutOfStock_result()
7302 
    try:
7303 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7304 
    except TransactionServiceException, ex:
7305 
      result.ex = ex
7306 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7307 
    result.write(oprot)
7308 
    oprot.writeMessageEnd()
7309 
    oprot.trans.flush()
7310 
 
3064 chandransh 7311 
  def process_verifyOrder(self, seqid, iprot, oprot):
7312 
    args = verifyOrder_args()
759 chandransh 7313 
    args.read(iprot)
7314 
    iprot.readMessageEnd()
3064 chandransh 7315 
    result = verifyOrder_result()
759 chandransh 7316 
    try:
3064 chandransh 7317 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7318 
    except TransactionServiceException, ex:
7319 
      result.ex = ex
3064 chandransh 7320 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7321 
    result.write(oprot)
7322 
    oprot.writeMessageEnd()
7323 
    oprot.trans.flush()
7324 
 
3064 chandransh 7325 
  def process_acceptOrder(self, seqid, iprot, oprot):
7326 
    args = acceptOrder_args()
1113 chandransh 7327 
    args.read(iprot)
7328 
    iprot.readMessageEnd()
3064 chandransh 7329 
    result = acceptOrder_result()
1113 chandransh 7330 
    try:
3064 chandransh 7331 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7332 
    except TransactionServiceException, ex:
7333 
      result.ex = ex
3064 chandransh 7334 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7335 
    result.write(oprot)
7336 
    oprot.writeMessageEnd()
7337 
    oprot.trans.flush()
7338 
 
3064 chandransh 7339 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7340 
    args = addBillingDetails_args()
1135 chandransh 7341 
    args.read(iprot)
7342 
    iprot.readMessageEnd()
3064 chandransh 7343 
    result = addBillingDetails_result()
1135 chandransh 7344 
    try:
5110 mandeep.dh 7345 
      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 7346 
    except TransactionServiceException, ex:
7347 
      result.ex = ex
3064 chandransh 7348 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7349 
    result.write(oprot)
7350 
    oprot.writeMessageEnd()
7351 
    oprot.trans.flush()
7352 
 
4579 rajveer 7353 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7354 
    args = addInvoiceNumber_args()
7355 
    args.read(iprot)
7356 
    iprot.readMessageEnd()
7357 
    result = addInvoiceNumber_result()
7358 
    try:
6756 amar.kumar 7359 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7360 
    except TransactionServiceException, ex:
7361 
      result.ex = ex
7362 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7363 
    result.write(oprot)
7364 
    oprot.writeMessageEnd()
7365 
    oprot.trans.flush()
7366 
 
4410 rajveer 7367 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7368 
    args = markOrdersAsShippedFromWarehouse_args()
7369 
    args.read(iprot)
7370 
    iprot.readMessageEnd()
7371 
    result = markOrdersAsShippedFromWarehouse_result()
7372 
    try:
4789 rajveer 7373 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7374 
    except TransactionServiceException, ex:
7375 
      result.ex = ex
7376 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7377 
    result.write(oprot)
7378 
    oprot.writeMessageEnd()
7379 
    oprot.trans.flush()
7380 
 
5676 rajveer 7381 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7382 
    args = markOrdersAsReturnedFromStore_args()
7383 
    args.read(iprot)
7384 
    iprot.readMessageEnd()
7385 
    result = markOrdersAsReturnedFromStore_result()
7386 
    try:
5713 rajveer 7387 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7388 
    except TransactionServiceException, ex:
7389 
      result.ex = ex
7390 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7391 
    result.write(oprot)
7392 
    oprot.writeMessageEnd()
7393 
    oprot.trans.flush()
7394 
 
3064 chandransh 7395 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7396 
    args = markOrdersAsPickedUp_args()
304 ashish 7397 
    args.read(iprot)
7398 
    iprot.readMessageEnd()
3064 chandransh 7399 
    result = markOrdersAsPickedUp_result()
7400 
    try:
4910 phani.kuma 7401 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7402 
    except TransactionServiceException, ex:
7403 
      result.ex = ex
7404 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7405 
    result.write(oprot)
7406 
    oprot.writeMessageEnd()
7407 
    oprot.trans.flush()
94 ashish 7408 
 
4910 phani.kuma 7409 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7410 
    args = getOrdersNotPickedUp_args()
7411 
    args.read(iprot)
7412 
    iprot.readMessageEnd()
7413 
    result = getOrdersNotPickedUp_result()
7414 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7415 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7416 
    result.write(oprot)
7417 
    oprot.writeMessageEnd()
7418 
    oprot.trans.flush()
7419 
 
3064 chandransh 7420 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7421 
    args = markOrdersAsDelivered_args()
304 ashish 7422 
    args.read(iprot)
7423 
    iprot.readMessageEnd()
3064 chandransh 7424 
    result = markOrdersAsDelivered_result()
7425 
    try:
7426 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7427 
    except TransactionServiceException, ex:
7428 
      result.ex = ex
7429 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7430 
    result.write(oprot)
7431 
    oprot.writeMessageEnd()
7432 
    oprot.trans.flush()
7433 
 
4910 phani.kuma 7434 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7435 
    args = markAsRTOrders_args()
1596 ankur.sing 7436 
    args.read(iprot)
7437 
    iprot.readMessageEnd()
4910 phani.kuma 7438 
    result = markAsRTOrders_result()
3064 chandransh 7439 
    try:
4910 phani.kuma 7440 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7441 
    except TransactionServiceException, ex:
7442 
      result.ex = ex
4910 phani.kuma 7443 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7444 
    result.write(oprot)
7445 
    oprot.writeMessageEnd()
7446 
    oprot.trans.flush()
304 ashish 7447 
 
4910 phani.kuma 7448 
  def process_getRTOrders(self, seqid, iprot, oprot):
7449 
    args = getRTOrders_args()
7450 
    args.read(iprot)
7451 
    iprot.readMessageEnd()
7452 
    result = getRTOrders_result()
7453 
    result.success = self._handler.getRTOrders(args.providerId)
7454 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7455 
    result.write(oprot)
7456 
    oprot.writeMessageEnd()
7457 
    oprot.trans.flush()
7458 
 
3064 chandransh 7459 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7460 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7461 
    args.read(iprot)
7462 
    iprot.readMessageEnd()
3064 chandransh 7463 
    result = updateNonDeliveryReason_result()
7464 
    try:
4910 phani.kuma 7465 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7466 
    except TransactionServiceException, ex:
7467 
      result.ex = ex
7468 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7469 
    result.write(oprot)
7470 
    oprot.writeMessageEnd()
7471 
    oprot.trans.flush()
1596 ankur.sing 7472 
 
4910 phani.kuma 7473 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7474 
    args = getNonDeliveredOrdersbyCourier_args()
7475 
    args.read(iprot)
7476 
    iprot.readMessageEnd()
7477 
    result = getNonDeliveredOrdersbyCourier_result()
7478 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7479 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7480 
    result.write(oprot)
7481 
    oprot.writeMessageEnd()
7482 
    oprot.trans.flush()
7483 
 
7484 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7485 
    args = markOrdersAsLocalConnected_args()
7486 
    args.read(iprot)
7487 
    iprot.readMessageEnd()
7488 
    result = markOrdersAsLocalConnected_result()
7489 
    try:
7490 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7491 
    except TransactionServiceException, ex:
7492 
      result.ex = ex
7493 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7494 
    result.write(oprot)
7495 
    oprot.writeMessageEnd()
7496 
    oprot.trans.flush()
7497 
 
7498 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7499 
    args = getOrdersNotLocalConnected_args()
7500 
    args.read(iprot)
7501 
    iprot.readMessageEnd()
7502 
    result = getOrdersNotLocalConnected_result()
7503 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7504 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7505 
    result.write(oprot)
7506 
    oprot.writeMessageEnd()
7507 
    oprot.trans.flush()
7508 
 
7509 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7510 
    args = markOrdersAsDestinationCityReached_args()
7511 
    args.read(iprot)
7512 
    iprot.readMessageEnd()
7513 
    result = markOrdersAsDestinationCityReached_result()
7514 
    try:
7515 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7516 
    except TransactionServiceException, ex:
7517 
      result.ex = ex
7518 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7519 
    result.write(oprot)
7520 
    oprot.writeMessageEnd()
7521 
    oprot.trans.flush()
7522 
 
7523 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7524 
    args = markOrdersAsFirstDeliveryAttempted_args()
7525 
    args.read(iprot)
7526 
    iprot.readMessageEnd()
7527 
    result = markOrdersAsFirstDeliveryAttempted_result()
7528 
    try:
7529 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7530 
    except TransactionServiceException, ex:
7531 
      result.ex = ex
7532 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7533 
    result.write(oprot)
7534 
    oprot.writeMessageEnd()
7535 
    oprot.trans.flush()
7536 
 
3064 chandransh 7537 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7538 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7539 
    args.read(iprot)
7540 
    iprot.readMessageEnd()
3064 chandransh 7541 
    result = getUndeliveredOrders_result()
7542 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7543 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7544 
    result.write(oprot)
7545 
    oprot.writeMessageEnd()
7546 
    oprot.trans.flush()
7547 
 
4783 phani.kuma 7548 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7549 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7550 
    args.read(iprot)
7551 
    iprot.readMessageEnd()
7552 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7553 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7554 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7555 
    result.write(oprot)
7556 
    oprot.writeMessageEnd()
7557 
    oprot.trans.flush()
7558 
 
2536 chandransh 7559 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7560 
    args = toggleDOAFlag_args()
7561 
    args.read(iprot)
7562 
    iprot.readMessageEnd()
7563 
    result = toggleDOAFlag_result()
7564 
    try:
7565 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7566 
    except TransactionServiceException, ex:
7567 
      result.ex = ex
7568 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7569 
    result.write(oprot)
7570 
    oprot.writeMessageEnd()
7571 
    oprot.trans.flush()
1886 ankur.sing 7572 
 
4712 rajveer 7573 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7574 
    args = markOrderAsDelivered_args()
7575 
    args.read(iprot)
7576 
    iprot.readMessageEnd()
7577 
    result = markOrderAsDelivered_result()
7578 
    try:
7579 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7580 
    except TransactionServiceException, ex:
7581 
      result.ex = ex
7582 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7583 
    result.write(oprot)
7584 
    oprot.writeMessageEnd()
7585 
    oprot.trans.flush()
7586 
 
5553 rajveer 7587 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7588 
    args = markOrderAsReceivedAtStore_args()
7589 
    args.read(iprot)
7590 
    iprot.readMessageEnd()
7591 
    result = markOrderAsReceivedAtStore_result()
7592 
    try:
7593 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7594 
    except TransactionServiceException, ex:
7595 
      result.ex = ex
7596 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7597 
    result.write(oprot)
7598 
    oprot.writeMessageEnd()
7599 
    oprot.trans.flush()
7600 
 
4454 rajveer 7601 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7602 
    args = markOrderDoaRequestReceived_args()
7603 
    args.read(iprot)
7604 
    iprot.readMessageEnd()
7605 
    result = markOrderDoaRequestReceived_result()
7606 
    try:
7607 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7608 
    except TransactionServiceException, ex:
7609 
      result.ex = ex
7610 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7611 
    result.write(oprot)
7612 
    oprot.writeMessageEnd()
7613 
    oprot.trans.flush()
7614 
 
7615 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7616 
    args = markOrderDoaRequestAuthorized_args()
7617 
    args.read(iprot)
7618 
    iprot.readMessageEnd()
7619 
    result = markOrderDoaRequestAuthorized_result()
7620 
    try:
7621 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7622 
    except TransactionServiceException, ex:
7623 
      result.ex = ex
7624 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7625 
    result.write(oprot)
7626 
    oprot.writeMessageEnd()
7627 
    oprot.trans.flush()
7628 
 
4488 rajveer 7629 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7630 
    args = markOrderReturnRequestReceived_args()
7631 
    args.read(iprot)
7632 
    iprot.readMessageEnd()
7633 
    result = markOrderReturnRequestReceived_result()
7634 
    try:
7635 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7636 
    except TransactionServiceException, ex:
7637 
      result.ex = ex
7638 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7639 
    result.write(oprot)
7640 
    oprot.writeMessageEnd()
7641 
    oprot.trans.flush()
7642 
 
7643 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7644 
    args = markOrderReturnRequestAuthorized_args()
7645 
    args.read(iprot)
7646 
    iprot.readMessageEnd()
7647 
    result = markOrderReturnRequestAuthorized_result()
7648 
    try:
7649 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7650 
    except TransactionServiceException, ex:
7651 
      result.ex = ex
7652 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7653 
    result.write(oprot)
7654 
    oprot.writeMessageEnd()
7655 
    oprot.trans.flush()
7656 
 
2536 chandransh 7657 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7658 
    args = requestPickupNumber_args()
7659 
    args.read(iprot)
7660 
    iprot.readMessageEnd()
7661 
    result = requestPickupNumber_result()
7662 
    try:
4579 rajveer 7663 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7664 
    except TransactionServiceException, ex:
7665 
      result.ex = ex
7666 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7667 
    result.write(oprot)
7668 
    oprot.writeMessageEnd()
7669 
    oprot.trans.flush()
7670 
 
7671 
  def process_authorizePickup(self, seqid, iprot, oprot):
7672 
    args = authorizePickup_args()
7673 
    args.read(iprot)
7674 
    iprot.readMessageEnd()
7675 
    result = authorizePickup_result()
7676 
    try:
4602 rajveer 7677 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7678 
    except TransactionServiceException, ex:
7679 
      result.ex = ex
7680 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7681 
    result.write(oprot)
7682 
    oprot.writeMessageEnd()
7683 
    oprot.trans.flush()
7684 
 
2764 chandransh 7685 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7686 
    args = markDoasAsPickedUp_args()
7687 
    args.read(iprot)
7688 
    iprot.readMessageEnd()
7689 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7690 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7691 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7692 
    result.write(oprot)
7693 
    oprot.writeMessageEnd()
7694 
    oprot.trans.flush()
7695 
 
4910 phani.kuma 7696 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7697 
    args = getDoasNotPickedUp_args()
7698 
    args.read(iprot)
7699 
    iprot.readMessageEnd()
7700 
    result = getDoasNotPickedUp_result()
7701 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7702 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7703 
    result.write(oprot)
7704 
    oprot.writeMessageEnd()
7705 
    oprot.trans.flush()
7706 
 
4741 phani.kuma 7707 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7708 
    args = markReturnOrdersAsPickedUp_args()
7709 
    args.read(iprot)
7710 
    iprot.readMessageEnd()
7711 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7712 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7713 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7714 
    result.write(oprot)
7715 
    oprot.writeMessageEnd()
7716 
    oprot.trans.flush()
7717 
 
4910 phani.kuma 7718 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7719 
    args = getReturnOrdersNotPickedUp_args()
7720 
    args.read(iprot)
7721 
    iprot.readMessageEnd()
7722 
    result = getReturnOrdersNotPickedUp_result()
7723 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7724 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7725 
    result.write(oprot)
7726 
    oprot.writeMessageEnd()
7727 
    oprot.trans.flush()
7728 
 
2616 chandransh 7729 
  def process_receiveReturn(self, seqid, iprot, oprot):
7730 
    args = receiveReturn_args()
2591 chandransh 7731 
    args.read(iprot)
7732 
    iprot.readMessageEnd()
2616 chandransh 7733 
    result = receiveReturn_result()
2591 chandransh 7734 
    try:
4479 rajveer 7735 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7736 
    except TransactionServiceException, ex:
7737 
      result.ex = ex
2616 chandransh 7738 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7739 
    result.write(oprot)
7740 
    oprot.writeMessageEnd()
7741 
    oprot.trans.flush()
2536 chandransh 7742 
 
2591 chandransh 7743 
  def process_validateDoa(self, seqid, iprot, oprot):
7744 
    args = validateDoa_args()
7745 
    args.read(iprot)
7746 
    iprot.readMessageEnd()
7747 
    result = validateDoa_result()
7748 
    try:
7749 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7750 
    except TransactionServiceException, ex:
7751 
      result.ex = ex
7752 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7753 
    result.write(oprot)
7754 
    oprot.writeMessageEnd()
7755 
    oprot.trans.flush()
7756 
 
4495 rajveer 7757 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7758 
    args = validateReturnProduct_args()
7759 
    args.read(iprot)
7760 
    iprot.readMessageEnd()
7761 
    result = validateReturnProduct_result()
7762 
    try:
7763 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7764 
    except TransactionServiceException, ex:
7765 
      result.ex = ex
7766 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7767 
    result.write(oprot)
7768 
    oprot.writeMessageEnd()
7769 
    oprot.trans.flush()
7770 
 
2616 chandransh 7771 
  def process_reshipOrder(self, seqid, iprot, oprot):
7772 
    args = reshipOrder_args()
7773 
    args.read(iprot)
7774 
    iprot.readMessageEnd()
7775 
    result = reshipOrder_result()
7776 
    try:
7777 
      result.success = self._handler.reshipOrder(args.orderId)
7778 
    except TransactionServiceException, ex:
7779 
      result.ex = ex
7780 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7781 
    result.write(oprot)
7782 
    oprot.writeMessageEnd()
7783 
    oprot.trans.flush()
2591 chandransh 7784 
 
2616 chandransh 7785 
  def process_refundOrder(self, seqid, iprot, oprot):
7786 
    args = refundOrder_args()
7787 
    args.read(iprot)
7788 
    iprot.readMessageEnd()
7789 
    result = refundOrder_result()
7790 
    try:
3226 chandransh 7791 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7792 
    except TransactionServiceException, ex:
7793 
      result.ex = ex
7794 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7795 
    result.write(oprot)
7796 
    oprot.writeMessageEnd()
7797 
    oprot.trans.flush()
7798 
 
2690 chandransh 7799 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7800 
    args = getReturnOrders_args()
7801 
    args.read(iprot)
7802 
    iprot.readMessageEnd()
7803 
    result = getReturnOrders_result()
7804 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7805 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7806 
    result.write(oprot)
7807 
    oprot.writeMessageEnd()
7808 
    oprot.trans.flush()
2616 chandransh 7809 
 
5481 phani.kuma 7810 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7811 
    args = getAllReturnOrders_args()
7812 
    args.read(iprot)
7813 
    iprot.readMessageEnd()
7814 
    result = getAllReturnOrders_result()
7815 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7816 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7817 
    result.write(oprot)
7818 
    oprot.writeMessageEnd()
7819 
    oprot.trans.flush()
7820 
 
2700 chandransh 7821 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7822 
    args = getReturnOrder_args()
7823 
    args.read(iprot)
7824 
    iprot.readMessageEnd()
7825 
    result = getReturnOrder_result()
7826 
    try:
7827 
      result.success = self._handler.getReturnOrder(args.id)
7828 
    except TransactionServiceException, ex:
7829 
      result.ex = ex
7830 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7831 
    result.write(oprot)
7832 
    oprot.writeMessageEnd()
7833 
    oprot.trans.flush()
7834 
 
2690 chandransh 7835 
  def process_processReturn(self, seqid, iprot, oprot):
7836 
    args = processReturn_args()
7837 
    args.read(iprot)
7838 
    iprot.readMessageEnd()
7839 
    result = processReturn_result()
7840 
    try:
7841 
      self._handler.processReturn(args.returnOrderId)
7842 
    except TransactionServiceException, ex:
7843 
      result.ex = ex
7844 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7845 
    result.write(oprot)
7846 
    oprot.writeMessageEnd()
7847 
    oprot.trans.flush()
7848 
 
3451 chandransh 7849 
  def process_updateWeight(self, seqid, iprot, oprot):
7850 
    args = updateWeight_args()
7851 
    args.read(iprot)
7852 
    iprot.readMessageEnd()
7853 
    result = updateWeight_result()
7854 
    try:
7855 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7856 
    except TransactionServiceException, ex:
7857 
      result.ex = ex
7858 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7859 
    result.write(oprot)
7860 
    oprot.writeMessageEnd()
7861 
    oprot.trans.flush()
2819 chandransh 7862 
 
3469 chandransh 7863 
  def process_changeItem(self, seqid, iprot, oprot):
7864 
    args = changeItem_args()
7865 
    args.read(iprot)
7866 
    iprot.readMessageEnd()
7867 
    result = changeItem_result()
7868 
    try:
7869 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7870 
    except TransactionServiceException, ex:
7871 
      result.ex = ex
7872 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7873 
    result.write(oprot)
7874 
    oprot.writeMessageEnd()
7875 
    oprot.trans.flush()
3451 chandransh 7876 
 
3469 chandransh 7877 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7878 
    args = shiftToWarehouse_args()
7879 
    args.read(iprot)
7880 
    iprot.readMessageEnd()
7881 
    result = shiftToWarehouse_result()
7882 
    try:
7883 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7884 
    except TransactionServiceException, ex:
7885 
      result.ex = ex
7886 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7887 
    result.write(oprot)
7888 
    oprot.writeMessageEnd()
7889 
    oprot.trans.flush()
7890 
 
3553 chandransh 7891 
  def process_addDelayReason(self, seqid, iprot, oprot):
7892 
    args = addDelayReason_args()
7893 
    args.read(iprot)
7894 
    iprot.readMessageEnd()
7895 
    result = addDelayReason_result()
7896 
    try:
4647 rajveer 7897 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7898 
    except TransactionServiceException, ex:
7899 
      result.ex = ex
7900 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7901 
    result.write(oprot)
7902 
    oprot.writeMessageEnd()
7903 
    oprot.trans.flush()
3469 chandransh 7904 
 
3956 chandransh 7905 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7906 
    args = reconcileCodCollection_args()
7907 
    args.read(iprot)
7908 
    iprot.readMessageEnd()
7909 
    result = reconcileCodCollection_result()
7910 
    try:
7911 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7912 
    except TransactionServiceException, ex:
7913 
      result.ex = ex
7914 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7915 
    result.write(oprot)
7916 
    oprot.writeMessageEnd()
7917 
    oprot.trans.flush()
3553 chandransh 7918 
 
4008 mandeep.dh 7919 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7920 
    args = getTransactionsRequiringExtraProcessing_args()
7921 
    args.read(iprot)
7922 
    iprot.readMessageEnd()
7923 
    result = getTransactionsRequiringExtraProcessing_result()
7924 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7925 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7926 
    result.write(oprot)
7927 
    oprot.writeMessageEnd()
7928 
    oprot.trans.flush()
3956 chandransh 7929 
 
4008 mandeep.dh 7930 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7931 
    args = markTransactionAsProcessed_args()
7932 
    args.read(iprot)
7933 
    iprot.readMessageEnd()
7934 
    result = markTransactionAsProcessed_result()
7935 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7936 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7937 
    result.write(oprot)
7938 
    oprot.writeMessageEnd()
7939 
    oprot.trans.flush()
7940 
 
4018 chandransh 7941 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7942 
    args = getItemWiseRiskyOrdersCount_args()
7943 
    args.read(iprot)
7944 
    iprot.readMessageEnd()
7945 
    result = getItemWiseRiskyOrdersCount_result()
7946 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7947 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7948 
    result.write(oprot)
7949 
    oprot.writeMessageEnd()
7950 
    oprot.trans.flush()
4008 mandeep.dh 7951 
 
4295 varun.gupt 7952 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7953 
    args = getOrdersForItemIds_args()
7954 
    args.read(iprot)
7955 
    iprot.readMessageEnd()
7956 
    result = getOrdersForItemIds_result()
7957 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7958 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7959 
    result.write(oprot)
7960 
    oprot.writeMessageEnd()
7961 
    oprot.trans.flush()
7962 
 
4247 rajveer 7963 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7964 
    args = markOrderCancellationRequestReceived_args()
7965 
    args.read(iprot)
7966 
    iprot.readMessageEnd()
7967 
    result = markOrderCancellationRequestReceived_result()
7968 
    try:
7969 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7970 
    except TransactionServiceException, ex:
7971 
      result.ex = ex
7972 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
4018 chandransh 7976 
 
4247 rajveer 7977 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7978 
    args = markOrderCancellationRequestConfirmed_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = markOrderCancellationRequestConfirmed_result()
7982 
    try:
7983 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7984 
    except TransactionServiceException, ex:
7985 
      result.ex = ex
7986 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7987 
    result.write(oprot)
7988 
    oprot.writeMessageEnd()
7989 
    oprot.trans.flush()
7990 
 
7991 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7992 
    args = markOrderCancellationRequestDenied_args()
7993 
    args.read(iprot)
7994 
    iprot.readMessageEnd()
7995 
    result = markOrderCancellationRequestDenied_result()
7996 
    try:
7997 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7998 
    except TransactionServiceException, ex:
7999 
      result.ex = ex
8000 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8001 
    result.write(oprot)
8002 
    oprot.writeMessageEnd()
8003 
    oprot.trans.flush()
8004 
 
4258 rajveer 8005 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8006 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8007 
    args.read(iprot)
8008 
    iprot.readMessageEnd()
4258 rajveer 8009 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8010 
    try:
4258 rajveer 8011 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8012 
    except TransactionServiceException, ex:
8013 
      result.ex = ex
4258 rajveer 8014 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8015 
    result.write(oprot)
8016 
    oprot.writeMessageEnd()
8017 
    oprot.trans.flush()
8018 
 
4259 anupam.sin 8019 
  def process_refundTransaction(self, seqid, iprot, oprot):
8020 
    args = refundTransaction_args()
8021 
    args.read(iprot)
8022 
    iprot.readMessageEnd()
8023 
    result = refundTransaction_result()
8024 
    try:
8025 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8026 
    except TransactionServiceException, ex:
8027 
      result.ex = ex
8028 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8029 
    result.write(oprot)
8030 
    oprot.writeMessageEnd()
8031 
    oprot.trans.flush()
4247 rajveer 8032 
 
4324 mandeep.dh 8033 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8034 
    args = updateShipmentAddress_args()
8035 
    args.read(iprot)
8036 
    iprot.readMessageEnd()
8037 
    result = updateShipmentAddress_result()
8038 
    try:
8039 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8040 
    except TransactionServiceException, ex:
8041 
      result.ex = ex
8042 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8043 
    result.write(oprot)
8044 
    oprot.writeMessageEnd()
8045 
    oprot.trans.flush()
8046 
 
4285 rajveer 8047 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8048 
    args = acceptOrdersForItemId_args()
8049 
    args.read(iprot)
8050 
    iprot.readMessageEnd()
8051 
    result = acceptOrdersForItemId_result()
8052 
    try:
8053 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8054 
    except TransactionServiceException, ex:
8055 
      result.ex = ex
8056 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8057 
    result.write(oprot)
8058 
    oprot.writeMessageEnd()
8059 
    oprot.trans.flush()
4259 anupam.sin 8060 
 
4303 rajveer 8061 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8062 
    args = markOrdersAsPORaised_args()
8063 
    args.read(iprot)
8064 
    iprot.readMessageEnd()
8065 
    result = markOrdersAsPORaised_result()
8066 
    try:
4369 rajveer 8067 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8068 
    except TransactionServiceException, ex:
8069 
      result.ex = ex
8070 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8071 
    result.write(oprot)
8072 
    oprot.writeMessageEnd()
8073 
    oprot.trans.flush()
4285 rajveer 8074 
 
4303 rajveer 8075 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8076 
    args = markOrdersAsReversalInitiated_args()
8077 
    args.read(iprot)
8078 
    iprot.readMessageEnd()
8079 
    result = markOrdersAsReversalInitiated_result()
8080 
    try:
4369 rajveer 8081 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8082 
    except TransactionServiceException, ex:
8083 
      result.ex = ex
8084 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8085 
    result.write(oprot)
8086 
    oprot.writeMessageEnd()
8087 
    oprot.trans.flush()
8088 
 
8089 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8090 
    args = markOrdersAsNotAvailabke_args()
8091 
    args.read(iprot)
8092 
    iprot.readMessageEnd()
8093 
    result = markOrdersAsNotAvailabke_result()
8094 
    try:
4369 rajveer 8095 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8096 
    except TransactionServiceException, ex:
8097 
      result.ex = ex
8098 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8099 
    result.write(oprot)
8100 
    oprot.writeMessageEnd()
8101 
    oprot.trans.flush()
8102 
 
4369 rajveer 8103 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8104 
    args = markOrdersAsTimeout_args()
8105 
    args.read(iprot)
8106 
    iprot.readMessageEnd()
8107 
    result = markOrdersAsTimeout_result()
8108 
    try:
8109 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8110 
    except TransactionServiceException, ex:
8111 
      result.ex = ex
8112 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8113 
    result.write(oprot)
8114 
    oprot.writeMessageEnd()
8115 
    oprot.trans.flush()
4303 rajveer 8116 
 
4662 rajveer 8117 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8118 
    args = markOrderAsLostInTransit_args()
8119 
    args.read(iprot)
8120 
    iprot.readMessageEnd()
8121 
    result = markOrderAsLostInTransit_result()
8122 
    try:
8123 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8124 
    except TransactionServiceException, ex:
8125 
      result.ex = ex
8126 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8127 
    result.write(oprot)
8128 
    oprot.writeMessageEnd()
8129 
    oprot.trans.flush()
8130 
 
4386 anupam.sin 8131 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8132 
    args = getOrderForAwb_args()
8133 
    args.read(iprot)
8134 
    iprot.readMessageEnd()
8135 
    result = getOrderForAwb_result()
8136 
    try:
8137 
      result.success = self._handler.getOrderForAwb(args.awb)
8138 
    except TransactionServiceException, ex:
8139 
      result.ex = ex
8140 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8141 
    result.write(oprot)
8142 
    oprot.writeMessageEnd()
8143 
    oprot.trans.flush()
4369 rajveer 8144 
 
4506 phani.kuma 8145 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8146 
    args = getOrdersForProviderForStatus_args()
8147 
    args.read(iprot)
8148 
    iprot.readMessageEnd()
8149 
    result = getOrdersForProviderForStatus_result()
8150 
    try:
4910 phani.kuma 8151 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8152 
    except TransactionServiceException, ex:
8153 
      result.ex = ex
8154 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8155 
    result.write(oprot)
8156 
    oprot.writeMessageEnd()
8157 
    oprot.trans.flush()
4386 anupam.sin 8158 
 
4600 varun.gupt 8159 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8160 
    args = getBilledOrdersForVendor_args()
8161 
    args.read(iprot)
8162 
    iprot.readMessageEnd()
8163 
    result = getBilledOrdersForVendor_result()
8164 
    try:
8165 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8166 
    except TransactionServiceException, ex:
8167 
      result.ex = ex
8168 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8169 
    result.write(oprot)
8170 
    oprot.writeMessageEnd()
8171 
    oprot.trans.flush()
4506 phani.kuma 8172 
 
4607 rajveer 8173 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8174 
    args = getSlippedSippingDateOrders_args()
8175 
    args.read(iprot)
8176 
    iprot.readMessageEnd()
8177 
    result = getSlippedSippingDateOrders_result()
8178 
    try:
8179 
      result.success = self._handler.getSlippedSippingDateOrders()
8180 
    except TransactionServiceException, ex:
8181 
      result.ex = ex
8182 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8183 
    result.write(oprot)
8184 
    oprot.writeMessageEnd()
8185 
    oprot.trans.flush()
8186 
 
4709 rajveer 8187 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8188 
    args = getCancelledOrders_args()
8189 
    args.read(iprot)
8190 
    iprot.readMessageEnd()
8191 
    result = getCancelledOrders_result()
8192 
    try:
8193 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8194 
    except TransactionServiceException, ex:
8195 
      result.ex = ex
8196 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8197 
    result.write(oprot)
8198 
    oprot.writeMessageEnd()
8199 
    oprot.trans.flush()
8200 
 
4600 varun.gupt 8201 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8202 
    args = saveBluedartSettlements_args()
8203 
    args.read(iprot)
8204 
    iprot.readMessageEnd()
8205 
    result = saveBluedartSettlements_result()
8206 
    try:
8207 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8208 
    except TransactionServiceException, ex:
8209 
      result.ex = ex
8210 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
8215 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8216 
    args = savePaymentSettlements_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = savePaymentSettlements_result()
8220 
    try:
4905 varun.gupt 8221 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8222 
    except TransactionServiceException, ex:
8223 
      result.ex = ex
8224 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8225 
    result.write(oprot)
8226 
    oprot.writeMessageEnd()
8227 
    oprot.trans.flush()
8228 
 
8229 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8230 
    args = saveEBSSettlementSummary_args()
8231 
    args.read(iprot)
8232 
    iprot.readMessageEnd()
8233 
    result = saveEBSSettlementSummary_result()
8234 
    try:
8235 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8236 
    except TransactionServiceException, ex:
8237 
      result.ex = ex
8238 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8239 
    result.write(oprot)
8240 
    oprot.writeMessageEnd()
8241 
    oprot.trans.flush()
8242 
 
5386 phani.kuma 8243 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8244 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8245 
    args.read(iprot)
8246 
    iprot.readMessageEnd()
5386 phani.kuma 8247 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8248 
    try:
5386 phani.kuma 8249 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8250 
    except TransactionServiceException, ex:
8251 
      result.ex = ex
5386 phani.kuma 8252 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8253 
    result.write(oprot)
8254 
    oprot.writeMessageEnd()
8255 
    oprot.trans.flush()
8256 
 
5386 phani.kuma 8257 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8258 
    args = getSettlementForCod_args()
8259 
    args.read(iprot)
8260 
    iprot.readMessageEnd()
8261 
    result = getSettlementForCod_result()
8262 
    try:
8263 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8264 
    except TransactionServiceException, ex:
8265 
      result.ex = ex
8266 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8267 
    result.write(oprot)
8268 
    oprot.writeMessageEnd()
8269 
    oprot.trans.flush()
8270 
 
4600 varun.gupt 8271 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8272 
    args = getEBSSettlementSummaries_args()
8273 
    args.read(iprot)
8274 
    iprot.readMessageEnd()
8275 
    result = getEBSSettlementSummaries_result()
8276 
    try:
8277 
      result.success = self._handler.getEBSSettlementSummaries()
8278 
    except TransactionServiceException, ex:
8279 
      result.ex = ex
8280 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8281 
    result.write(oprot)
8282 
    oprot.writeMessageEnd()
8283 
    oprot.trans.flush()
8284 
 
8285 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8286 
    args = markEBSSettlementUploaded_args()
8287 
    args.read(iprot)
8288 
    iprot.readMessageEnd()
8289 
    result = markEBSSettlementUploaded_result()
8290 
    try:
8291 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8292 
    except TransactionServiceException, ex:
8293 
      result.ex = ex
8294 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8295 
    result.write(oprot)
8296 
    oprot.writeMessageEnd()
8297 
    oprot.trans.flush()
8298 
 
8299 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8300 
    args = getEBSSettlementDate_args()
8301 
    args.read(iprot)
8302 
    iprot.readMessageEnd()
8303 
    result = getEBSSettlementDate_result()
8304 
    try:
8305 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8306 
    except TransactionServiceException, ex:
8307 
      result.ex = ex
8308 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8309 
    result.write(oprot)
8310 
    oprot.writeMessageEnd()
8311 
    oprot.trans.flush()
8312 
 
4715 varun.gupt 8313 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8314 
    args = getSettlementsByDate_args()
8315 
    args.read(iprot)
8316 
    iprot.readMessageEnd()
8317 
    result = getSettlementsByDate_result()
8318 
    try:
8319 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8320 
    except TransactionServiceException, ex:
8321 
      result.ex = ex
8322 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8323 
    result.write(oprot)
8324 
    oprot.writeMessageEnd()
8325 
    oprot.trans.flush()
4600 varun.gupt 8326 
 
4715 varun.gupt 8327 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8328 
    args = getReshippedOrderIds_args()
8329 
    args.read(iprot)
8330 
    iprot.readMessageEnd()
8331 
    result = getReshippedOrderIds_result()
8332 
    try:
8333 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8334 
    except TransactionServiceException, ex:
8335 
      result.ex = ex
8336 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8337 
    result.write(oprot)
8338 
    oprot.writeMessageEnd()
8339 
    oprot.trans.flush()
8340 
 
5481 phani.kuma 8341 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8342 
    args = getBilledOrders_args()
4875 varun.gupt 8343 
    args.read(iprot)
8344 
    iprot.readMessageEnd()
5481 phani.kuma 8345 
    result = getBilledOrders_result()
4875 varun.gupt 8346 
    try:
5481 phani.kuma 8347 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8348 
    except TransactionServiceException, ex:
8349 
      result.ex = ex
5481 phani.kuma 8350 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8351 
    result.write(oprot)
8352 
    oprot.writeMessageEnd()
8353 
    oprot.trans.flush()
4757 mandeep.dh 8354 
 
5031 varun.gupt 8355 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8356 
    args = getStatusDistributionOfOrders_args()
8357 
    args.read(iprot)
8358 
    iprot.readMessageEnd()
8359 
    result = getStatusDistributionOfOrders_result()
8360 
    try:
8361 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8362 
    except TransactionServiceException, ex:
8363 
      result.ex = ex
8364 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8365 
    result.write(oprot)
8366 
    oprot.writeMessageEnd()
8367 
    oprot.trans.flush()
4875 varun.gupt 8368 
 
5067 varun.gupt 8369 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8370 
    args = getOrderIdsForStatus_args()
8371 
    args.read(iprot)
8372 
    iprot.readMessageEnd()
8373 
    result = getOrderIdsForStatus_result()
8374 
    try:
8375 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8376 
    except TransactionServiceException, ex:
8377 
      result.ex = ex
8378 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8379 
    result.write(oprot)
8380 
    oprot.writeMessageEnd()
8381 
    oprot.trans.flush()
5031 varun.gupt 8382 
 
5348 anupam.sin 8383 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8384 
    args = updateCODAgent_args()
8385 
    args.read(iprot)
8386 
    iprot.readMessageEnd()
8387 
    result = updateCODAgent_result()
8388 
    try:
8389 
      self._handler.updateCODAgent(args.agent, args.orderId)
8390 
    except TransactionServiceException, ex:
8391 
      result.ex = ex
8392 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8393 
    result.write(oprot)
8394 
    oprot.writeMessageEnd()
8395 
    oprot.trans.flush()
8396 
 
5099 varun.gupt 8397 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8398 
    args = updateOrderAsPaidToVendor_args()
8399 
    args.read(iprot)
8400 
    iprot.readMessageEnd()
8401 
    result = updateOrderAsPaidToVendor_result()
8402 
    try:
8403 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8404 
    except TransactionServiceException, ex:
8405 
      result.ex = ex
8406 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8407 
    result.write(oprot)
8408 
    oprot.writeMessageEnd()
8409 
    oprot.trans.flush()
5067 varun.gupt 8410 
 
5386 phani.kuma 8411 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8412 
    args = updateOrderOnlyAsPaidToVendor_args()
8413 
    args.read(iprot)
8414 
    iprot.readMessageEnd()
8415 
    result = updateOrderOnlyAsPaidToVendor_result()
8416 
    try:
8417 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8418 
    except TransactionServiceException, ex:
8419 
      result.ex = ex
8420 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8421 
    result.write(oprot)
8422 
    oprot.writeMessageEnd()
8423 
    oprot.trans.flush()
8424 
 
5208 varun.gupt 8425 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8426 
    args = getRefundedOrdersMarkedPaid_args()
8427 
    args.read(iprot)
8428 
    iprot.readMessageEnd()
8429 
    result = getRefundedOrdersMarkedPaid_result()
8430 
    try:
8431 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8432 
    except TransactionServiceException, ex:
8433 
      result.ex = ex
8434 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8435 
    result.write(oprot)
8436 
    oprot.writeMessageEnd()
8437 
    oprot.trans.flush()
5099 varun.gupt 8438 
 
5447 anupam.sin 8439 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8440 
    args = getAllVerificationAgents_args()
8441 
    args.read(iprot)
8442 
    iprot.readMessageEnd()
8443 
    result = getAllVerificationAgents_result()
8444 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8445 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8446 
    result.write(oprot)
8447 
    oprot.writeMessageEnd()
8448 
    oprot.trans.flush()
5208 varun.gupt 8449 
 
5527 anupam.sin 8450 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8451 
    args = getAllAttributesForOrderId_args()
8452 
    args.read(iprot)
8453 
    iprot.readMessageEnd()
8454 
    result = getAllAttributesForOrderId_result()
8455 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8456 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8457 
    result.write(oprot)
8458 
    oprot.writeMessageEnd()
8459 
    oprot.trans.flush()
5447 anupam.sin 8460 
 
5676 rajveer 8461 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8462 
    args = setOrderAttributes_args()
8463 
    args.read(iprot)
8464 
    iprot.readMessageEnd()
8465 
    result = setOrderAttributes_result()
8466 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8467 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8468 
    result.write(oprot)
8469 
    oprot.writeMessageEnd()
8470 
    oprot.trans.flush()
8471 
 
5527 anupam.sin 8472 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8473 
    args = setOrderAttributeForTransaction_args()
8474 
    args.read(iprot)
8475 
    iprot.readMessageEnd()
8476 
    result = setOrderAttributeForTransaction_result()
8477 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8478 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8479 
    result.write(oprot)
8480 
    oprot.writeMessageEnd()
8481 
    oprot.trans.flush()
8482 
 
5553 rajveer 8483 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8484 
    args = getReceivePendingOrders_args()
8485 
    args.read(iprot)
8486 
    iprot.readMessageEnd()
8487 
    result = getReceivePendingOrders_result()
8488 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8489 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8490 
    result.write(oprot)
8491 
    oprot.writeMessageEnd()
8492 
    oprot.trans.flush()
5527 anupam.sin 8493 
 
5553 rajveer 8494 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8495 
    args = getReceivedAtStoreOrders_args()
8496 
    args.read(iprot)
8497 
    iprot.readMessageEnd()
8498 
    result = getReceivedAtStoreOrders_result()
8499 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8500 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8501 
    result.write(oprot)
8502 
    oprot.writeMessageEnd()
8503 
    oprot.trans.flush()
8504 
 
5713 rajveer 8505 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8506 
    args = getOrdersCollectionAtStore_args()
8507 
    args.read(iprot)
8508 
    iprot.readMessageEnd()
8509 
    result = getOrdersCollectionAtStore_result()
8510 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8511 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8512 
    result.write(oprot)
8513 
    oprot.writeMessageEnd()
8514 
    oprot.trans.flush()
8515 
 
5833 rajveer 8516 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8517 
    args = getOrderAttributeValue_args()
8518 
    args.read(iprot)
8519 
    iprot.readMessageEnd()
8520 
    result = getOrderAttributeValue_result()
8521 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8522 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8523 
    result.write(oprot)
8524 
    oprot.writeMessageEnd()
8525 
    oprot.trans.flush()
8526 
 
6019 rajveer 8527 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8528 
    args = changeJacketNumber_args()
8529 
    args.read(iprot)
8530 
    iprot.readMessageEnd()
8531 
    result = changeJacketNumber_result()
8532 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8533 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8534 
    result.write(oprot)
8535 
    oprot.writeMessageEnd()
8536 
    oprot.trans.flush()
8537 
 
8538 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8539 
    args = markOrderAsRtoInTransit_args()
8540 
    args.read(iprot)
8541 
    iprot.readMessageEnd()
8542 
    result = markOrderAsRtoInTransit_result()
8543 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8544 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8545 
    result.write(oprot)
8546 
    oprot.writeMessageEnd()
8547 
    oprot.trans.flush()
8548 
 
5593 mandeep.dh 8549 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8550 
    args = acceptOrderForItem_args()
8551 
    args.read(iprot)
8552 
    iprot.readMessageEnd()
8553 
    result = acceptOrderForItem_result()
8554 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8555 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8556 
    result.write(oprot)
8557 
    oprot.writeMessageEnd()
8558 
    oprot.trans.flush()
5553 rajveer 8559 
 
6000 mandeep.dh 8560 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8561 
    args = createRechargeOrder_args()
8562 
    args.read(iprot)
8563 
    iprot.readMessageEnd()
8564 
    result = createRechargeOrder_result()
8565 
    try:
8566 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8567 
    except TransactionServiceException, ex:
8568 
      result.ex = ex
8569 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8570 
    result.write(oprot)
8571 
    oprot.writeMessageEnd()
8572 
    oprot.trans.flush()
5593 mandeep.dh 8573 
 
6031 rajveer 8574 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8575 
    args = getRechargeOrder_args()
8576 
    args.read(iprot)
8577 
    iprot.readMessageEnd()
8578 
    result = getRechargeOrder_result()
8579 
    try:
8580 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8581 
    except TransactionServiceException, ex:
8582 
      result.ex = ex
8583 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8584 
    result.write(oprot)
8585 
    oprot.writeMessageEnd()
8586 
    oprot.trans.flush()
8587 
 
8588 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8589 
    args = getRechargeOrders_args()
8590 
    args.read(iprot)
8591 
    iprot.readMessageEnd()
8592 
    result = getRechargeOrders_result()
8593 
    result.success = self._handler.getRechargeOrders(args.userId)
8594 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8595 
    result.write(oprot)
8596 
    oprot.writeMessageEnd()
8597 
    oprot.trans.flush()
8598 
 
6000 mandeep.dh 8599 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8600 
    args = updateRechargeOrderStatus_args()
8601 
    args.read(iprot)
8602 
    iprot.readMessageEnd()
8603 
    result = updateRechargeOrderStatus_result()
8604 
    try:
6031 rajveer 8605 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8606 
    except TransactionServiceException, ex:
8607 
      result.ex = ex
8608 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8609 
    result.write(oprot)
8610 
    oprot.writeMessageEnd()
8611 
    oprot.trans.flush()
8612 
 
8613 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8614 
    args = activateRechargeTxn_args()
8615 
    args.read(iprot)
8616 
    iprot.readMessageEnd()
8617 
    result = activateRechargeTxn_result()
8618 
    try:
6031 rajveer 8619 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8620 
    except TransactionServiceException, ex:
8621 
      result.ex = ex
8622 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8623 
    result.write(oprot)
8624 
    oprot.writeMessageEnd()
8625 
    oprot.trans.flush()
8626 
 
6031 rajveer 8627 
  def process_getUserWallet(self, seqid, iprot, oprot):
8628 
    args = getUserWallet_args()
6000 mandeep.dh 8629 
    args.read(iprot)
8630 
    iprot.readMessageEnd()
6031 rajveer 8631 
    result = getUserWallet_result()
8632 
    result.success = self._handler.getUserWallet(args.userId)
8633 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8634 
    result.write(oprot)
8635 
    oprot.writeMessageEnd()
8636 
    oprot.trans.flush()
8637 
 
6031 rajveer 8638 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8639 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8640 
    args.read(iprot)
8641 
    iprot.readMessageEnd()
6031 rajveer 8642 
    result = getUserWalletHistory_result()
8643 
    result.success = self._handler.getUserWalletHistory(args.userId)
8644 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8645 
    result.write(oprot)
8646 
    oprot.writeMessageEnd()
8647 
    oprot.trans.flush()
8648 
 
6050 anupam.sin 8649 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8650 
    args = getRechargeOrdersForTransaction_args()
8651 
    args.read(iprot)
8652 
    iprot.readMessageEnd()
8653 
    result = getRechargeOrdersForTransaction_result()
8654 
    try:
8655 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8656 
    except TransactionServiceException, ex:
8657 
      result.ex = ex
8658 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8659 
    result.write(oprot)
8660 
    oprot.writeMessageEnd()
8661 
    oprot.trans.flush()
8662 
 
6048 rajveer 8663 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8664 
    args = getServiceProviders_args()
8665 
    args.read(iprot)
8666 
    iprot.readMessageEnd()
8667 
    result = getServiceProviders_result()
6206 rajveer 8668 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8669 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8670 
    result.write(oprot)
8671 
    oprot.writeMessageEnd()
8672 
    oprot.trans.flush()
6000 mandeep.dh 8673 
 
6048 rajveer 8674 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8675 
    args = getServiceProviderForDevice_args()
8676 
    args.read(iprot)
8677 
    iprot.readMessageEnd()
8678 
    result = getServiceProviderForDevice_result()
6049 rajveer 8679 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8680 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8681 
    result.write(oprot)
8682 
    oprot.writeMessageEnd()
8683 
    oprot.trans.flush()
8684 
 
6269 rajveer 8685 
  def process_validateRecharge(self, seqid, iprot, oprot):
8686 
    args = validateRecharge_args()
8687 
    args.read(iprot)
8688 
    iprot.readMessageEnd()
8689 
    result = validateRecharge_result()
6591 anupam.sin 8690 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8691 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8692 
    result.write(oprot)
8693 
    oprot.writeMessageEnd()
8694 
    oprot.trans.flush()
8695 
 
6094 rajveer 8696 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8697 
    args = getRechargeOrdersForDevice_args()
8698 
    args.read(iprot)
8699 
    iprot.readMessageEnd()
8700 
    result = getRechargeOrdersForDevice_result()
8701 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8702 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8703 
    result.write(oprot)
8704 
    oprot.writeMessageEnd()
8705 
    oprot.trans.flush()
6048 rajveer 8706 
 
6094 rajveer 8707 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8708 
    args = addAmountToWallet_args()
8709 
    args.read(iprot)
8710 
    iprot.readMessageEnd()
8711 
    result = addAmountToWallet_result()
8712 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8713 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8714 
    result.write(oprot)
8715 
    oprot.writeMessageEnd()
8716 
    oprot.trans.flush()
8717 
 
6188 rajveer 8718 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8719 
    args = getRechargeStatistics_args()
8720 
    args.read(iprot)
8721 
    iprot.readMessageEnd()
8722 
    result = getRechargeStatistics_result()
8723 
    result.success = self._handler.getRechargeStatistics()
8724 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8725 
    result.write(oprot)
8726 
    oprot.writeMessageEnd()
8727 
    oprot.trans.flush()
8728 
 
6154 rajveer 8729 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8730 
    args = getRechargeOrdersForStatus_args()
8731 
    args.read(iprot)
8732 
    iprot.readMessageEnd()
8733 
    result = getRechargeOrdersForStatus_result()
8734 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8735 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8736 
    result.write(oprot)
8737 
    oprot.writeMessageEnd()
8738 
    oprot.trans.flush()
6094 rajveer 8739 
 
6159 rajveer 8740 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8741 
    args = getPlansForOperator_args()
8742 
    args.read(iprot)
8743 
    iprot.readMessageEnd()
8744 
    result = getPlansForOperator_result()
8745 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8746 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8747 
    result.write(oprot)
8748 
    oprot.writeMessageEnd()
8749 
    oprot.trans.flush()
6154 rajveer 8750 
 
6289 anupam.sin 8751 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8752 
    args = getRechargeDenominations_args()
8753 
    args.read(iprot)
8754 
    iprot.readMessageEnd()
8755 
    result = getRechargeDenominations_result()
8756 
    try:
6307 anupam.sin 8757 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8758 
    except TransactionServiceException, ex:
8759 
      result.ex = ex
8760 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8761 
    result.write(oprot)
8762 
    oprot.writeMessageEnd()
8763 
    oprot.trans.flush()
6159 rajveer 8764 
 
6371 rajveer 8765 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8766 
    args = updateAvailabilityStatus_args()
8767 
    args.read(iprot)
8768 
    iprot.readMessageEnd()
8769 
    result = updateAvailabilityStatus_result()
8770 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8771 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8772 
    result.write(oprot)
8773 
    oprot.writeMessageEnd()
8774 
    oprot.trans.flush()
6289 anupam.sin 8775 
 
6389 rajveer 8776 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8777 
    args = getAvailableEmiSchemes_args()
8778 
    args.read(iprot)
8779 
    iprot.readMessageEnd()
8780 
    result = getAvailableEmiSchemes_result()
8781 
    result.success = self._handler.getAvailableEmiSchemes()
8782 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8783 
    result.write(oprot)
8784 
    oprot.writeMessageEnd()
8785 
    oprot.trans.flush()
6371 rajveer 8786 
 
6389 rajveer 8787 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8788 
    args = getMiscCharges_args()
8789 
    args.read(iprot)
8790 
    iprot.readMessageEnd()
8791 
    result = getMiscCharges_result()
8792 
    result.success = self._handler.getMiscCharges(args.transactionId)
8793 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8794 
    result.write(oprot)
8795 
    oprot.writeMessageEnd()
8796 
    oprot.trans.flush()
8797 
 
6507 anupam.sin 8798 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8799 
    args = refundRechargeOrder_args()
8800 
    args.read(iprot)
8801 
    iprot.readMessageEnd()
8802 
    result = refundRechargeOrder_result()
8803 
    try:
8804 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8805 
    except TransactionServiceException, ex:
8806 
      result.ex = ex
8807 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8808 
    result.write(oprot)
8809 
    oprot.writeMessageEnd()
8810 
    oprot.trans.flush()
6389 rajveer 8811 
 
6821 amar.kumar 8812 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8813 
    args = getPhysicalOrders_args()
8814 
    args.read(iprot)
8815 
    iprot.readMessageEnd()
8816 
    result = getPhysicalOrders_result()
8817 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8818 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8819 
    result.write(oprot)
8820 
    oprot.writeMessageEnd()
8821 
    oprot.trans.flush()
6507 anupam.sin 8822 
 
6906 rajveer 8823 
  def process_getDocument(self, seqid, iprot, oprot):
8824 
    args = getDocument_args()
8825 
    args.read(iprot)
8826 
    iprot.readMessageEnd()
8827 
    result = getDocument_result()
8828 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8829 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8830 
    result.write(oprot)
8831 
    oprot.writeMessageEnd()
8832 
    oprot.trans.flush()
6821 amar.kumar 8833 
 
6985 anupam.sin 8834 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
8835 
    args = changeShippingAddress_args()
8836 
    args.read(iprot)
8837 
    iprot.readMessageEnd()
8838 
    result = changeShippingAddress_result()
8839 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
8840 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
8841 
    result.write(oprot)
8842 
    oprot.writeMessageEnd()
8843 
    oprot.trans.flush()
6906 rajveer 8844 
 
6988 rajveer 8845 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
8846 
    args = retrieveInvoice_args()
8847 
    args.read(iprot)
8848 
    iprot.readMessageEnd()
8849 
    result = retrieveInvoice_result()
8850 
    result.success = self._handler.retrieveInvoice(args.orderId)
8851 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
8852 
    result.write(oprot)
8853 
    oprot.writeMessageEnd()
8854 
    oprot.trans.flush()
6985 anupam.sin 8855 
 
6988 rajveer 8856 
 
94 ashish 8857 
# HELPER FUNCTIONS AND STRUCTURES
8858 
 
8859 
class createTransaction_args:
8860 
  """
8861 
  Attributes:
8862 
   - transaction
8863 
  """
8864 
 
8865 
  thrift_spec = (
8866 
    None, # 0
8867 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8868 
  )
8869 
 
8870 
  def __init__(self, transaction=None,):
8871 
    self.transaction = transaction
8872 
 
8873 
  def read(self, iprot):
8874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8876 
      return
8877 
    iprot.readStructBegin()
8878 
    while True:
8879 
      (fname, ftype, fid) = iprot.readFieldBegin()
8880 
      if ftype == TType.STOP:
8881 
        break
8882 
      if fid == 1:
8883 
        if ftype == TType.STRUCT:
8884 
          self.transaction = Transaction()
8885 
          self.transaction.read(iprot)
8886 
        else:
8887 
          iprot.skip(ftype)
8888 
      else:
8889 
        iprot.skip(ftype)
8890 
      iprot.readFieldEnd()
8891 
    iprot.readStructEnd()
8892 
 
8893 
  def write(self, oprot):
8894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8896 
      return
8897 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8898 
    if self.transaction is not None:
94 ashish 8899 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8900 
      self.transaction.write(oprot)
8901 
      oprot.writeFieldEnd()
8902 
    oprot.writeFieldStop()
8903 
    oprot.writeStructEnd()
8904 
 
3431 rajveer 8905 
  def validate(self):
8906 
    return
8907 
 
8908 
 
94 ashish 8909 
  def __repr__(self):
8910 
    L = ['%s=%r' % (key, value)
8911 
      for key, value in self.__dict__.iteritems()]
8912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8913 
 
8914 
  def __eq__(self, other):
8915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8916 
 
8917 
  def __ne__(self, other):
8918 
    return not (self == other)
8919 
 
8920 
class createTransaction_result:
8921 
  """
8922 
  Attributes:
132 ashish 8923 
   - success
94 ashish 8924 
   - ex
8925 
  """
8926 
 
8927 
  thrift_spec = (
132 ashish 8928 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8929 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8930 
  )
8931 
 
132 ashish 8932 
  def __init__(self, success=None, ex=None,):
8933 
    self.success = success
94 ashish 8934 
    self.ex = ex
8935 
 
8936 
  def read(self, iprot):
8937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8939 
      return
8940 
    iprot.readStructBegin()
8941 
    while True:
8942 
      (fname, ftype, fid) = iprot.readFieldBegin()
8943 
      if ftype == TType.STOP:
8944 
        break
132 ashish 8945 
      if fid == 0:
8946 
        if ftype == TType.I64:
8947 
          self.success = iprot.readI64();
8948 
        else:
8949 
          iprot.skip(ftype)
8950 
      elif fid == 1:
94 ashish 8951 
        if ftype == TType.STRUCT:
8952 
          self.ex = TransactionServiceException()
8953 
          self.ex.read(iprot)
8954 
        else:
8955 
          iprot.skip(ftype)
8956 
      else:
8957 
        iprot.skip(ftype)
8958 
      iprot.readFieldEnd()
8959 
    iprot.readStructEnd()
8960 
 
8961 
  def write(self, oprot):
8962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8964 
      return
8965 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8966 
    if self.success is not None:
132 ashish 8967 
      oprot.writeFieldBegin('success', TType.I64, 0)
8968 
      oprot.writeI64(self.success)
8969 
      oprot.writeFieldEnd()
3431 rajveer 8970 
    if self.ex is not None:
94 ashish 8971 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8972 
      self.ex.write(oprot)
8973 
      oprot.writeFieldEnd()
8974 
    oprot.writeFieldStop()
8975 
    oprot.writeStructEnd()
8976 
 
3431 rajveer 8977 
  def validate(self):
8978 
    return
8979 
 
8980 
 
94 ashish 8981 
  def __repr__(self):
8982 
    L = ['%s=%r' % (key, value)
8983 
      for key, value in self.__dict__.iteritems()]
8984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8985 
 
8986 
  def __eq__(self, other):
8987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8988 
 
8989 
  def __ne__(self, other):
8990 
    return not (self == other)
8991 
 
8992 
class getTransaction_args:
8993 
  """
8994 
  Attributes:
8995 
   - id
8996 
  """
8997 
 
8998 
  thrift_spec = (
8999 
    None, # 0
9000 
    (1, TType.I64, 'id', None, None, ), # 1
9001 
  )
9002 
 
9003 
  def __init__(self, id=None,):
9004 
    self.id = id
9005 
 
9006 
  def read(self, iprot):
9007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9009 
      return
9010 
    iprot.readStructBegin()
9011 
    while True:
9012 
      (fname, ftype, fid) = iprot.readFieldBegin()
9013 
      if ftype == TType.STOP:
9014 
        break
9015 
      if fid == 1:
9016 
        if ftype == TType.I64:
9017 
          self.id = iprot.readI64();
9018 
        else:
9019 
          iprot.skip(ftype)
9020 
      else:
9021 
        iprot.skip(ftype)
9022 
      iprot.readFieldEnd()
9023 
    iprot.readStructEnd()
9024 
 
9025 
  def write(self, oprot):
9026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9028 
      return
9029 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9030 
    if self.id is not None:
94 ashish 9031 
      oprot.writeFieldBegin('id', TType.I64, 1)
9032 
      oprot.writeI64(self.id)
9033 
      oprot.writeFieldEnd()
9034 
    oprot.writeFieldStop()
9035 
    oprot.writeStructEnd()
9036 
 
3431 rajveer 9037 
  def validate(self):
9038 
    return
9039 
 
9040 
 
94 ashish 9041 
  def __repr__(self):
9042 
    L = ['%s=%r' % (key, value)
9043 
      for key, value in self.__dict__.iteritems()]
9044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9045 
 
9046 
  def __eq__(self, other):
9047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9048 
 
9049 
  def __ne__(self, other):
9050 
    return not (self == other)
9051 
 
9052 
class getTransaction_result:
9053 
  """
9054 
  Attributes:
9055 
   - success
9056 
   - ex
9057 
  """
9058 
 
9059 
  thrift_spec = (
9060 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9062 
  )
9063 
 
9064 
  def __init__(self, success=None, ex=None,):
9065 
    self.success = success
9066 
    self.ex = ex
9067 
 
9068 
  def read(self, iprot):
9069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9071 
      return
9072 
    iprot.readStructBegin()
9073 
    while True:
9074 
      (fname, ftype, fid) = iprot.readFieldBegin()
9075 
      if ftype == TType.STOP:
9076 
        break
9077 
      if fid == 0:
9078 
        if ftype == TType.STRUCT:
9079 
          self.success = Transaction()
9080 
          self.success.read(iprot)
9081 
        else:
9082 
          iprot.skip(ftype)
9083 
      elif fid == 1:
9084 
        if ftype == TType.STRUCT:
9085 
          self.ex = TransactionServiceException()
9086 
          self.ex.read(iprot)
9087 
        else:
9088 
          iprot.skip(ftype)
9089 
      else:
9090 
        iprot.skip(ftype)
9091 
      iprot.readFieldEnd()
9092 
    iprot.readStructEnd()
9093 
 
9094 
  def write(self, oprot):
9095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9097 
      return
9098 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9099 
    if self.success is not None:
94 ashish 9100 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9101 
      self.success.write(oprot)
9102 
      oprot.writeFieldEnd()
3431 rajveer 9103 
    if self.ex is not None:
94 ashish 9104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9105 
      self.ex.write(oprot)
9106 
      oprot.writeFieldEnd()
9107 
    oprot.writeFieldStop()
9108 
    oprot.writeStructEnd()
9109 
 
3431 rajveer 9110 
  def validate(self):
9111 
    return
9112 
 
9113 
 
94 ashish 9114 
  def __repr__(self):
9115 
    L = ['%s=%r' % (key, value)
9116 
      for key, value in self.__dict__.iteritems()]
9117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9118 
 
9119 
  def __eq__(self, other):
9120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9121 
 
9122 
  def __ne__(self, other):
9123 
    return not (self == other)
9124 
 
9125 
class getTransactionsForCustomer_args:
9126 
  """
9127 
  Attributes:
9128 
   - customerId
9129 
   - from_date
9130 
   - to_date
9131 
   - status
9132 
  """
9133 
 
9134 
  thrift_spec = (
9135 
    None, # 0
9136 
    (1, TType.I64, 'customerId', None, None, ), # 1
9137 
    (2, TType.I64, 'from_date', None, None, ), # 2
9138 
    (3, TType.I64, 'to_date', None, None, ), # 3
9139 
    (4, TType.I32, 'status', None, None, ), # 4
9140 
  )
9141 
 
9142 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9143 
    self.customerId = customerId
9144 
    self.from_date = from_date
9145 
    self.to_date = to_date
9146 
    self.status = status
9147 
 
9148 
  def read(self, iprot):
9149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9151 
      return
9152 
    iprot.readStructBegin()
9153 
    while True:
9154 
      (fname, ftype, fid) = iprot.readFieldBegin()
9155 
      if ftype == TType.STOP:
9156 
        break
9157 
      if fid == 1:
9158 
        if ftype == TType.I64:
9159 
          self.customerId = iprot.readI64();
9160 
        else:
9161 
          iprot.skip(ftype)
9162 
      elif fid == 2:
9163 
        if ftype == TType.I64:
9164 
          self.from_date = iprot.readI64();
9165 
        else:
9166 
          iprot.skip(ftype)
9167 
      elif fid == 3:
9168 
        if ftype == TType.I64:
9169 
          self.to_date = iprot.readI64();
9170 
        else:
9171 
          iprot.skip(ftype)
9172 
      elif fid == 4:
9173 
        if ftype == TType.I32:
9174 
          self.status = iprot.readI32();
9175 
        else:
9176 
          iprot.skip(ftype)
9177 
      else:
9178 
        iprot.skip(ftype)
9179 
      iprot.readFieldEnd()
9180 
    iprot.readStructEnd()
9181 
 
9182 
  def write(self, oprot):
9183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9185 
      return
9186 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9187 
    if self.customerId is not None:
94 ashish 9188 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9189 
      oprot.writeI64(self.customerId)
9190 
      oprot.writeFieldEnd()
3431 rajveer 9191 
    if self.from_date is not None:
94 ashish 9192 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9193 
      oprot.writeI64(self.from_date)
9194 
      oprot.writeFieldEnd()
3431 rajveer 9195 
    if self.to_date is not None:
94 ashish 9196 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9197 
      oprot.writeI64(self.to_date)
9198 
      oprot.writeFieldEnd()
3431 rajveer 9199 
    if self.status is not None:
94 ashish 9200 
      oprot.writeFieldBegin('status', TType.I32, 4)
9201 
      oprot.writeI32(self.status)
9202 
      oprot.writeFieldEnd()
9203 
    oprot.writeFieldStop()
9204 
    oprot.writeStructEnd()
9205 
 
3431 rajveer 9206 
  def validate(self):
9207 
    return
9208 
 
9209 
 
94 ashish 9210 
  def __repr__(self):
9211 
    L = ['%s=%r' % (key, value)
9212 
      for key, value in self.__dict__.iteritems()]
9213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9214 
 
9215 
  def __eq__(self, other):
9216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9217 
 
9218 
  def __ne__(self, other):
9219 
    return not (self == other)
9220 
 
9221 
class getTransactionsForCustomer_result:
9222 
  """
9223 
  Attributes:
9224 
   - success
9225 
   - ex
9226 
  """
9227 
 
9228 
  thrift_spec = (
9229 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9231 
  )
9232 
 
9233 
  def __init__(self, success=None, ex=None,):
9234 
    self.success = success
9235 
    self.ex = ex
9236 
 
9237 
  def read(self, iprot):
9238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9240 
      return
9241 
    iprot.readStructBegin()
9242 
    while True:
9243 
      (fname, ftype, fid) = iprot.readFieldBegin()
9244 
      if ftype == TType.STOP:
9245 
        break
9246 
      if fid == 0:
9247 
        if ftype == TType.LIST:
9248 
          self.success = []
6188 rajveer 9249 
          (_etype109, _size106) = iprot.readListBegin()
9250 
          for _i110 in xrange(_size106):
9251 
            _elem111 = Transaction()
9252 
            _elem111.read(iprot)
9253 
            self.success.append(_elem111)
94 ashish 9254 
          iprot.readListEnd()
9255 
        else:
9256 
          iprot.skip(ftype)
9257 
      elif fid == 1:
9258 
        if ftype == TType.STRUCT:
9259 
          self.ex = TransactionServiceException()
9260 
          self.ex.read(iprot)
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      else:
9264 
        iprot.skip(ftype)
9265 
      iprot.readFieldEnd()
9266 
    iprot.readStructEnd()
9267 
 
9268 
  def write(self, oprot):
9269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9271 
      return
9272 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9273 
    if self.success is not None:
94 ashish 9274 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9275 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9276 
      for iter112 in self.success:
9277 
        iter112.write(oprot)
94 ashish 9278 
      oprot.writeListEnd()
9279 
      oprot.writeFieldEnd()
3431 rajveer 9280 
    if self.ex is not None:
94 ashish 9281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9282 
      self.ex.write(oprot)
9283 
      oprot.writeFieldEnd()
9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
3431 rajveer 9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
94 ashish 9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
132 ashish 9302 
class getTransactionsForShoppingCartId_args:
9303 
  """
9304 
  Attributes:
9305 
   - shoppingCartId
9306 
  """
9307 
 
9308 
  thrift_spec = (
9309 
    None, # 0
9310 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9311 
  )
9312 
 
9313 
  def __init__(self, shoppingCartId=None,):
9314 
    self.shoppingCartId = shoppingCartId
9315 
 
9316 
  def read(self, iprot):
9317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9319 
      return
9320 
    iprot.readStructBegin()
9321 
    while True:
9322 
      (fname, ftype, fid) = iprot.readFieldBegin()
9323 
      if ftype == TType.STOP:
9324 
        break
9325 
      if fid == 1:
9326 
        if ftype == TType.I64:
9327 
          self.shoppingCartId = iprot.readI64();
9328 
        else:
9329 
          iprot.skip(ftype)
9330 
      else:
9331 
        iprot.skip(ftype)
9332 
      iprot.readFieldEnd()
9333 
    iprot.readStructEnd()
9334 
 
9335 
  def write(self, oprot):
9336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9338 
      return
9339 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9340 
    if self.shoppingCartId is not None:
132 ashish 9341 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9342 
      oprot.writeI64(self.shoppingCartId)
9343 
      oprot.writeFieldEnd()
9344 
    oprot.writeFieldStop()
9345 
    oprot.writeStructEnd()
9346 
 
3431 rajveer 9347 
  def validate(self):
9348 
    return
9349 
 
9350 
 
132 ashish 9351 
  def __repr__(self):
9352 
    L = ['%s=%r' % (key, value)
9353 
      for key, value in self.__dict__.iteritems()]
9354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9355 
 
9356 
  def __eq__(self, other):
9357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9358 
 
9359 
  def __ne__(self, other):
9360 
    return not (self == other)
9361 
 
9362 
class getTransactionsForShoppingCartId_result:
9363 
  """
9364 
  Attributes:
9365 
   - success
9366 
   - ex
9367 
  """
9368 
 
9369 
  thrift_spec = (
9370 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9371 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9372 
  )
9373 
 
9374 
  def __init__(self, success=None, ex=None,):
9375 
    self.success = success
9376 
    self.ex = ex
9377 
 
9378 
  def read(self, iprot):
9379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9381 
      return
9382 
    iprot.readStructBegin()
9383 
    while True:
9384 
      (fname, ftype, fid) = iprot.readFieldBegin()
9385 
      if ftype == TType.STOP:
9386 
        break
9387 
      if fid == 0:
9388 
        if ftype == TType.LIST:
9389 
          self.success = []
6188 rajveer 9390 
          (_etype116, _size113) = iprot.readListBegin()
9391 
          for _i117 in xrange(_size113):
9392 
            _elem118 = Transaction()
9393 
            _elem118.read(iprot)
9394 
            self.success.append(_elem118)
132 ashish 9395 
          iprot.readListEnd()
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      elif fid == 1:
9399 
        if ftype == TType.STRUCT:
9400 
          self.ex = TransactionServiceException()
9401 
          self.ex.read(iprot)
9402 
        else:
9403 
          iprot.skip(ftype)
9404 
      else:
9405 
        iprot.skip(ftype)
9406 
      iprot.readFieldEnd()
9407 
    iprot.readStructEnd()
9408 
 
9409 
  def write(self, oprot):
9410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9412 
      return
9413 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9414 
    if self.success is not None:
132 ashish 9415 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9416 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9417 
      for iter119 in self.success:
9418 
        iter119.write(oprot)
132 ashish 9419 
      oprot.writeListEnd()
9420 
      oprot.writeFieldEnd()
3431 rajveer 9421 
    if self.ex is not None:
132 ashish 9422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9423 
      self.ex.write(oprot)
9424 
      oprot.writeFieldEnd()
9425 
    oprot.writeFieldStop()
9426 
    oprot.writeStructEnd()
9427 
 
3431 rajveer 9428 
  def validate(self):
9429 
    return
9430 
 
9431 
 
132 ashish 9432 
  def __repr__(self):
9433 
    L = ['%s=%r' % (key, value)
9434 
      for key, value in self.__dict__.iteritems()]
9435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9436 
 
9437 
  def __eq__(self, other):
9438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9439 
 
9440 
  def __ne__(self, other):
9441 
    return not (self == other)
9442 
 
94 ashish 9443 
class getTransactionStatus_args:
9444 
  """
9445 
  Attributes:
9446 
   - transactionId
9447 
  """
9448 
 
9449 
  thrift_spec = (
9450 
    None, # 0
9451 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9452 
  )
9453 
 
9454 
  def __init__(self, transactionId=None,):
9455 
    self.transactionId = transactionId
9456 
 
9457 
  def read(self, iprot):
9458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9460 
      return
9461 
    iprot.readStructBegin()
9462 
    while True:
9463 
      (fname, ftype, fid) = iprot.readFieldBegin()
9464 
      if ftype == TType.STOP:
9465 
        break
9466 
      if fid == 1:
9467 
        if ftype == TType.I64:
9468 
          self.transactionId = iprot.readI64();
9469 
        else:
9470 
          iprot.skip(ftype)
9471 
      else:
9472 
        iprot.skip(ftype)
9473 
      iprot.readFieldEnd()
9474 
    iprot.readStructEnd()
9475 
 
9476 
  def write(self, oprot):
9477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9479 
      return
9480 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9481 
    if self.transactionId is not None:
94 ashish 9482 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9483 
      oprot.writeI64(self.transactionId)
9484 
      oprot.writeFieldEnd()
9485 
    oprot.writeFieldStop()
9486 
    oprot.writeStructEnd()
9487 
 
3431 rajveer 9488 
  def validate(self):
9489 
    return
9490 
 
9491 
 
94 ashish 9492 
  def __repr__(self):
9493 
    L = ['%s=%r' % (key, value)
9494 
      for key, value in self.__dict__.iteritems()]
9495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9496 
 
9497 
  def __eq__(self, other):
9498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9499 
 
9500 
  def __ne__(self, other):
9501 
    return not (self == other)
9502 
 
9503 
class getTransactionStatus_result:
9504 
  """
9505 
  Attributes:
9506 
   - success
9507 
   - ex
9508 
  """
9509 
 
9510 
  thrift_spec = (
9511 
    (0, TType.I32, 'success', None, None, ), # 0
9512 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9513 
  )
9514 
 
9515 
  def __init__(self, success=None, ex=None,):
9516 
    self.success = success
9517 
    self.ex = ex
9518 
 
9519 
  def read(self, iprot):
9520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9522 
      return
9523 
    iprot.readStructBegin()
9524 
    while True:
9525 
      (fname, ftype, fid) = iprot.readFieldBegin()
9526 
      if ftype == TType.STOP:
9527 
        break
9528 
      if fid == 0:
9529 
        if ftype == TType.I32:
9530 
          self.success = iprot.readI32();
9531 
        else:
9532 
          iprot.skip(ftype)
9533 
      elif fid == 1:
9534 
        if ftype == TType.STRUCT:
9535 
          self.ex = TransactionServiceException()
9536 
          self.ex.read(iprot)
9537 
        else:
9538 
          iprot.skip(ftype)
9539 
      else:
9540 
        iprot.skip(ftype)
9541 
      iprot.readFieldEnd()
9542 
    iprot.readStructEnd()
9543 
 
9544 
  def write(self, oprot):
9545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9547 
      return
9548 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9549 
    if self.success is not None:
94 ashish 9550 
      oprot.writeFieldBegin('success', TType.I32, 0)
9551 
      oprot.writeI32(self.success)
9552 
      oprot.writeFieldEnd()
3431 rajveer 9553 
    if self.ex is not None:
94 ashish 9554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9555 
      self.ex.write(oprot)
9556 
      oprot.writeFieldEnd()
9557 
    oprot.writeFieldStop()
9558 
    oprot.writeStructEnd()
9559 
 
3431 rajveer 9560 
  def validate(self):
9561 
    return
9562 
 
9563 
 
94 ashish 9564 
  def __repr__(self):
9565 
    L = ['%s=%r' % (key, value)
9566 
      for key, value in self.__dict__.iteritems()]
9567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9568 
 
9569 
  def __eq__(self, other):
9570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9571 
 
9572 
  def __ne__(self, other):
9573 
    return not (self == other)
9574 
 
9575 
class changeTransactionStatus_args:
9576 
  """
9577 
  Attributes:
9578 
   - transactionId
9579 
   - status
9580 
   - description
5527 anupam.sin 9581 
   - pickUp
9582 
   - orderType
94 ashish 9583 
  """
9584 
 
9585 
  thrift_spec = (
9586 
    None, # 0
9587 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9588 
    (2, TType.I32, 'status', None, None, ), # 2
9589 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9590 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9591 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9592 
  )
9593 
 
5527 anupam.sin 9594 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9595 
    self.transactionId = transactionId
9596 
    self.status = status
9597 
    self.description = description
5527 anupam.sin 9598 
    self.pickUp = pickUp
9599 
    self.orderType = orderType
94 ashish 9600 
 
9601 
  def read(self, iprot):
9602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9604 
      return
9605 
    iprot.readStructBegin()
9606 
    while True:
9607 
      (fname, ftype, fid) = iprot.readFieldBegin()
9608 
      if ftype == TType.STOP:
9609 
        break
9610 
      if fid == 1:
9611 
        if ftype == TType.I64:
9612 
          self.transactionId = iprot.readI64();
9613 
        else:
9614 
          iprot.skip(ftype)
9615 
      elif fid == 2:
9616 
        if ftype == TType.I32:
9617 
          self.status = iprot.readI32();
9618 
        else:
9619 
          iprot.skip(ftype)
9620 
      elif fid == 3:
9621 
        if ftype == TType.STRING:
9622 
          self.description = iprot.readString();
9623 
        else:
9624 
          iprot.skip(ftype)
5387 rajveer 9625 
      elif fid == 4:
5527 anupam.sin 9626 
        if ftype == TType.I64:
9627 
          self.pickUp = iprot.readI64();
5387 rajveer 9628 
        else:
9629 
          iprot.skip(ftype)
5527 anupam.sin 9630 
      elif fid == 5:
9631 
        if ftype == TType.I32:
9632 
          self.orderType = iprot.readI32();
9633 
        else:
9634 
          iprot.skip(ftype)
94 ashish 9635 
      else:
9636 
        iprot.skip(ftype)
9637 
      iprot.readFieldEnd()
9638 
    iprot.readStructEnd()
9639 
 
9640 
  def write(self, oprot):
9641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9643 
      return
9644 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9645 
    if self.transactionId is not None:
94 ashish 9646 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9647 
      oprot.writeI64(self.transactionId)
9648 
      oprot.writeFieldEnd()
3431 rajveer 9649 
    if self.status is not None:
94 ashish 9650 
      oprot.writeFieldBegin('status', TType.I32, 2)
9651 
      oprot.writeI32(self.status)
9652 
      oprot.writeFieldEnd()
3431 rajveer 9653 
    if self.description is not None:
94 ashish 9654 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9655 
      oprot.writeString(self.description)
9656 
      oprot.writeFieldEnd()
5527 anupam.sin 9657 
    if self.pickUp is not None:
9658 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9659 
      oprot.writeI64(self.pickUp)
5387 rajveer 9660 
      oprot.writeFieldEnd()
5527 anupam.sin 9661 
    if self.orderType is not None:
9662 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9663 
      oprot.writeI32(self.orderType)
9664 
      oprot.writeFieldEnd()
94 ashish 9665 
    oprot.writeFieldStop()
9666 
    oprot.writeStructEnd()
9667 
 
3431 rajveer 9668 
  def validate(self):
9669 
    return
9670 
 
9671 
 
94 ashish 9672 
  def __repr__(self):
9673 
    L = ['%s=%r' % (key, value)
9674 
      for key, value in self.__dict__.iteritems()]
9675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9676 
 
9677 
  def __eq__(self, other):
9678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9679 
 
9680 
  def __ne__(self, other):
9681 
    return not (self == other)
9682 
 
9683 
class changeTransactionStatus_result:
9684 
  """
9685 
  Attributes:
9686 
   - success
9687 
   - ex
9688 
  """
9689 
 
9690 
  thrift_spec = (
9691 
    (0, TType.BOOL, 'success', None, None, ), # 0
9692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9693 
  )
9694 
 
9695 
  def __init__(self, success=None, ex=None,):
9696 
    self.success = success
9697 
    self.ex = ex
9698 
 
9699 
  def read(self, iprot):
9700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9702 
      return
9703 
    iprot.readStructBegin()
9704 
    while True:
9705 
      (fname, ftype, fid) = iprot.readFieldBegin()
9706 
      if ftype == TType.STOP:
9707 
        break
9708 
      if fid == 0:
9709 
        if ftype == TType.BOOL:
9710 
          self.success = iprot.readBool();
9711 
        else:
9712 
          iprot.skip(ftype)
9713 
      elif fid == 1:
9714 
        if ftype == TType.STRUCT:
9715 
          self.ex = TransactionServiceException()
9716 
          self.ex.read(iprot)
9717 
        else:
9718 
          iprot.skip(ftype)
9719 
      else:
9720 
        iprot.skip(ftype)
9721 
      iprot.readFieldEnd()
9722 
    iprot.readStructEnd()
9723 
 
9724 
  def write(self, oprot):
9725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9727 
      return
9728 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9729 
    if self.success is not None:
94 ashish 9730 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9731 
      oprot.writeBool(self.success)
9732 
      oprot.writeFieldEnd()
3431 rajveer 9733 
    if self.ex is not None:
94 ashish 9734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9735 
      self.ex.write(oprot)
9736 
      oprot.writeFieldEnd()
9737 
    oprot.writeFieldStop()
9738 
    oprot.writeStructEnd()
9739 
 
3431 rajveer 9740 
  def validate(self):
9741 
    return
9742 
 
9743 
 
94 ashish 9744 
  def __repr__(self):
9745 
    L = ['%s=%r' % (key, value)
9746 
      for key, value in self.__dict__.iteritems()]
9747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9748 
 
9749 
  def __eq__(self, other):
9750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9751 
 
9752 
  def __ne__(self, other):
9753 
    return not (self == other)
9754 
 
1398 varun.gupt 9755 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9756 
  """
9757 
  Attributes:
9758 
   - transactionId
9759 
  """
9760 
 
9761 
  thrift_spec = (
9762 
    None, # 0
9763 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9764 
  )
9765 
 
9766 
  def __init__(self, transactionId=None,):
9767 
    self.transactionId = transactionId
9768 
 
9769 
  def read(self, iprot):
9770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9772 
      return
9773 
    iprot.readStructBegin()
9774 
    while True:
9775 
      (fname, ftype, fid) = iprot.readFieldBegin()
9776 
      if ftype == TType.STOP:
9777 
        break
9778 
      if fid == 1:
9779 
        if ftype == TType.I64:
9780 
          self.transactionId = iprot.readI64();
9781 
        else:
9782 
          iprot.skip(ftype)
9783 
      else:
9784 
        iprot.skip(ftype)
9785 
      iprot.readFieldEnd()
9786 
    iprot.readStructEnd()
9787 
 
9788 
  def write(self, oprot):
9789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9791 
      return
1398 varun.gupt 9792 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9793 
    if self.transactionId is not None:
1382 varun.gupt 9794 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9795 
      oprot.writeI64(self.transactionId)
9796 
      oprot.writeFieldEnd()
9797 
    oprot.writeFieldStop()
9798 
    oprot.writeStructEnd()
9799 
 
3431 rajveer 9800 
  def validate(self):
9801 
    return
9802 
 
9803 
 
1382 varun.gupt 9804 
  def __repr__(self):
9805 
    L = ['%s=%r' % (key, value)
9806 
      for key, value in self.__dict__.iteritems()]
9807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9808 
 
9809 
  def __eq__(self, other):
9810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9811 
 
9812 
  def __ne__(self, other):
9813 
    return not (self == other)
9814 
 
1398 varun.gupt 9815 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9816 
  """
9817 
  Attributes:
9818 
   - success
9819 
   - ex
9820 
  """
9821 
 
9822 
  thrift_spec = (
9823 
    (0, TType.BOOL, 'success', None, None, ), # 0
9824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9825 
  )
9826 
 
9827 
  def __init__(self, success=None, ex=None,):
9828 
    self.success = success
9829 
    self.ex = ex
9830 
 
9831 
  def read(self, iprot):
9832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9834 
      return
9835 
    iprot.readStructBegin()
9836 
    while True:
9837 
      (fname, ftype, fid) = iprot.readFieldBegin()
9838 
      if ftype == TType.STOP:
9839 
        break
9840 
      if fid == 0:
9841 
        if ftype == TType.BOOL:
9842 
          self.success = iprot.readBool();
9843 
        else:
9844 
          iprot.skip(ftype)
9845 
      elif fid == 1:
9846 
        if ftype == TType.STRUCT:
9847 
          self.ex = TransactionServiceException()
9848 
          self.ex.read(iprot)
9849 
        else:
9850 
          iprot.skip(ftype)
9851 
      else:
9852 
        iprot.skip(ftype)
9853 
      iprot.readFieldEnd()
9854 
    iprot.readStructEnd()
9855 
 
9856 
  def write(self, oprot):
9857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9859 
      return
1398 varun.gupt 9860 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9861 
    if self.success is not None:
1382 varun.gupt 9862 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9863 
      oprot.writeBool(self.success)
9864 
      oprot.writeFieldEnd()
3431 rajveer 9865 
    if self.ex is not None:
1382 varun.gupt 9866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9867 
      self.ex.write(oprot)
9868 
      oprot.writeFieldEnd()
9869 
    oprot.writeFieldStop()
9870 
    oprot.writeStructEnd()
9871 
 
3431 rajveer 9872 
  def validate(self):
9873 
    return
9874 
 
9875 
 
1382 varun.gupt 9876 
  def __repr__(self):
9877 
    L = ['%s=%r' % (key, value)
9878 
      for key, value in self.__dict__.iteritems()]
9879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9880 
 
9881 
  def __eq__(self, other):
9882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9883 
 
9884 
  def __ne__(self, other):
9885 
    return not (self == other)
9886 
 
483 rajveer 9887 
class getAllOrders_args:
94 ashish 9888 
  """
9889 
  Attributes:
4801 anupam.sin 9890 
   - statuses
483 rajveer 9891 
   - from_date
9892 
   - to_date
9893 
   - warehouse_id
94 ashish 9894 
  """
9895 
 
9896 
  thrift_spec = (
9897 
    None, # 0
4801 anupam.sin 9898 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9899 
    (2, TType.I64, 'from_date', None, None, ), # 2
9900 
    (3, TType.I64, 'to_date', None, None, ), # 3
9901 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9902 
  )
9903 
 
4801 anupam.sin 9904 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9905 
    self.statuses = statuses
483 rajveer 9906 
    self.from_date = from_date
9907 
    self.to_date = to_date
9908 
    self.warehouse_id = warehouse_id
94 ashish 9909 
 
9910 
  def read(self, iprot):
9911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9913 
      return
9914 
    iprot.readStructBegin()
9915 
    while True:
9916 
      (fname, ftype, fid) = iprot.readFieldBegin()
9917 
      if ftype == TType.STOP:
9918 
        break
9919 
      if fid == 1:
4801 anupam.sin 9920 
        if ftype == TType.LIST:
9921 
          self.statuses = []
6188 rajveer 9922 
          (_etype123, _size120) = iprot.readListBegin()
9923 
          for _i124 in xrange(_size120):
9924 
            _elem125 = iprot.readI32();
9925 
            self.statuses.append(_elem125)
4801 anupam.sin 9926 
          iprot.readListEnd()
94 ashish 9927 
        else:
9928 
          iprot.skip(ftype)
483 rajveer 9929 
      elif fid == 2:
9930 
        if ftype == TType.I64:
9931 
          self.from_date = iprot.readI64();
94 ashish 9932 
        else:
9933 
          iprot.skip(ftype)
483 rajveer 9934 
      elif fid == 3:
9935 
        if ftype == TType.I64:
9936 
          self.to_date = iprot.readI64();
94 ashish 9937 
        else:
9938 
          iprot.skip(ftype)
483 rajveer 9939 
      elif fid == 4:
94 ashish 9940 
        if ftype == TType.I64:
483 rajveer 9941 
          self.warehouse_id = iprot.readI64();
94 ashish 9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      else:
9945 
        iprot.skip(ftype)
9946 
      iprot.readFieldEnd()
9947 
    iprot.readStructEnd()
9948 
 
9949 
  def write(self, oprot):
9950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9952 
      return
483 rajveer 9953 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9954 
    if self.statuses is not None:
9955 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9956 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9957 
      for iter126 in self.statuses:
9958 
        oprot.writeI32(iter126)
4801 anupam.sin 9959 
      oprot.writeListEnd()
94 ashish 9960 
      oprot.writeFieldEnd()
3431 rajveer 9961 
    if self.from_date is not None:
483 rajveer 9962 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9963 
      oprot.writeI64(self.from_date)
94 ashish 9964 
      oprot.writeFieldEnd()
3431 rajveer 9965 
    if self.to_date is not None:
483 rajveer 9966 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9967 
      oprot.writeI64(self.to_date)
94 ashish 9968 
      oprot.writeFieldEnd()
3431 rajveer 9969 
    if self.warehouse_id is not None:
483 rajveer 9970 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9971 
      oprot.writeI64(self.warehouse_id)
94 ashish 9972 
      oprot.writeFieldEnd()
9973 
    oprot.writeFieldStop()
9974 
    oprot.writeStructEnd()
9975 
 
3431 rajveer 9976 
  def validate(self):
9977 
    return
9978 
 
9979 
 
94 ashish 9980 
  def __repr__(self):
9981 
    L = ['%s=%r' % (key, value)
9982 
      for key, value in self.__dict__.iteritems()]
9983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9984 
 
9985 
  def __eq__(self, other):
9986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9987 
 
9988 
  def __ne__(self, other):
9989 
    return not (self == other)
9990 
 
483 rajveer 9991 
class getAllOrders_result:
94 ashish 9992 
  """
9993 
  Attributes:
9994 
   - success
9995 
   - ex
9996 
  """
9997 
 
9998 
  thrift_spec = (
483 rajveer 9999 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10001 
  )
10002 
 
10003 
  def __init__(self, success=None, ex=None,):
10004 
    self.success = success
10005 
    self.ex = ex
10006 
 
10007 
  def read(self, iprot):
10008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10010 
      return
10011 
    iprot.readStructBegin()
10012 
    while True:
10013 
      (fname, ftype, fid) = iprot.readFieldBegin()
10014 
      if ftype == TType.STOP:
10015 
        break
10016 
      if fid == 0:
483 rajveer 10017 
        if ftype == TType.LIST:
10018 
          self.success = []
6188 rajveer 10019 
          (_etype130, _size127) = iprot.readListBegin()
10020 
          for _i131 in xrange(_size127):
10021 
            _elem132 = Order()
10022 
            _elem132.read(iprot)
10023 
            self.success.append(_elem132)
483 rajveer 10024 
          iprot.readListEnd()
94 ashish 10025 
        else:
10026 
          iprot.skip(ftype)
10027 
      elif fid == 1:
10028 
        if ftype == TType.STRUCT:
10029 
          self.ex = TransactionServiceException()
10030 
          self.ex.read(iprot)
10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      else:
10034 
        iprot.skip(ftype)
10035 
      iprot.readFieldEnd()
10036 
    iprot.readStructEnd()
10037 
 
10038 
  def write(self, oprot):
10039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10041 
      return
483 rajveer 10042 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10043 
    if self.success is not None:
483 rajveer 10044 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10045 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10046 
      for iter133 in self.success:
10047 
        iter133.write(oprot)
483 rajveer 10048 
      oprot.writeListEnd()
94 ashish 10049 
      oprot.writeFieldEnd()
3431 rajveer 10050 
    if self.ex is not None:
94 ashish 10051 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10052 
      self.ex.write(oprot)
10053 
      oprot.writeFieldEnd()
10054 
    oprot.writeFieldStop()
10055 
    oprot.writeStructEnd()
10056 
 
3431 rajveer 10057 
  def validate(self):
10058 
    return
10059 
 
10060 
 
94 ashish 10061 
  def __repr__(self):
10062 
    L = ['%s=%r' % (key, value)
10063 
      for key, value in self.__dict__.iteritems()]
10064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10065 
 
10066 
  def __eq__(self, other):
10067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10068 
 
10069 
  def __ne__(self, other):
10070 
    return not (self == other)
10071 
 
4133 chandransh 10072 
class getOrdersInBatch_args:
10073 
  """
10074 
  Attributes:
10075 
   - statuses
10076 
   - offset
10077 
   - limit
10078 
   - warehouse_id
10079 
  """
10080 
 
10081 
  thrift_spec = (
10082 
    None, # 0
10083 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10084 
    (2, TType.I64, 'offset', None, None, ), # 2
10085 
    (3, TType.I64, 'limit', None, None, ), # 3
10086 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10087 
  )
10088 
 
10089 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10090 
    self.statuses = statuses
10091 
    self.offset = offset
10092 
    self.limit = limit
10093 
    self.warehouse_id = warehouse_id
10094 
 
10095 
  def read(self, iprot):
10096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10098 
      return
10099 
    iprot.readStructBegin()
10100 
    while True:
10101 
      (fname, ftype, fid) = iprot.readFieldBegin()
10102 
      if ftype == TType.STOP:
10103 
        break
10104 
      if fid == 1:
10105 
        if ftype == TType.LIST:
10106 
          self.statuses = []
6188 rajveer 10107 
          (_etype137, _size134) = iprot.readListBegin()
10108 
          for _i138 in xrange(_size134):
10109 
            _elem139 = iprot.readI32();
10110 
            self.statuses.append(_elem139)
4133 chandransh 10111 
          iprot.readListEnd()
10112 
        else:
10113 
          iprot.skip(ftype)
10114 
      elif fid == 2:
10115 
        if ftype == TType.I64:
10116 
          self.offset = iprot.readI64();
10117 
        else:
10118 
          iprot.skip(ftype)
10119 
      elif fid == 3:
10120 
        if ftype == TType.I64:
10121 
          self.limit = iprot.readI64();
10122 
        else:
10123 
          iprot.skip(ftype)
10124 
      elif fid == 4:
10125 
        if ftype == TType.I64:
10126 
          self.warehouse_id = iprot.readI64();
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getOrdersInBatch_args')
10139 
    if self.statuses is not None:
10140 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10141 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10142 
      for iter140 in self.statuses:
10143 
        oprot.writeI32(iter140)
4133 chandransh 10144 
      oprot.writeListEnd()
10145 
      oprot.writeFieldEnd()
10146 
    if self.offset is not None:
10147 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10148 
      oprot.writeI64(self.offset)
10149 
      oprot.writeFieldEnd()
10150 
    if self.limit is not None:
10151 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10152 
      oprot.writeI64(self.limit)
10153 
      oprot.writeFieldEnd()
10154 
    if self.warehouse_id is not None:
10155 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10156 
      oprot.writeI64(self.warehouse_id)
10157 
      oprot.writeFieldEnd()
10158 
    oprot.writeFieldStop()
10159 
    oprot.writeStructEnd()
10160 
 
10161 
  def validate(self):
10162 
    return
10163 
 
10164 
 
10165 
  def __repr__(self):
10166 
    L = ['%s=%r' % (key, value)
10167 
      for key, value in self.__dict__.iteritems()]
10168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10169 
 
10170 
  def __eq__(self, other):
10171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10172 
 
10173 
  def __ne__(self, other):
10174 
    return not (self == other)
10175 
 
10176 
class getOrdersInBatch_result:
10177 
  """
10178 
  Attributes:
10179 
   - success
10180 
   - ex
10181 
  """
10182 
 
10183 
  thrift_spec = (
10184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10186 
  )
10187 
 
10188 
  def __init__(self, success=None, ex=None,):
10189 
    self.success = success
10190 
    self.ex = ex
10191 
 
10192 
  def read(self, iprot):
10193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10195 
      return
10196 
    iprot.readStructBegin()
10197 
    while True:
10198 
      (fname, ftype, fid) = iprot.readFieldBegin()
10199 
      if ftype == TType.STOP:
10200 
        break
10201 
      if fid == 0:
10202 
        if ftype == TType.LIST:
10203 
          self.success = []
6188 rajveer 10204 
          (_etype144, _size141) = iprot.readListBegin()
10205 
          for _i145 in xrange(_size141):
10206 
            _elem146 = Order()
10207 
            _elem146.read(iprot)
10208 
            self.success.append(_elem146)
4133 chandransh 10209 
          iprot.readListEnd()
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      elif fid == 1:
10213 
        if ftype == TType.STRUCT:
10214 
          self.ex = TransactionServiceException()
10215 
          self.ex.read(iprot)
10216 
        else:
10217 
          iprot.skip(ftype)
10218 
      else:
10219 
        iprot.skip(ftype)
10220 
      iprot.readFieldEnd()
10221 
    iprot.readStructEnd()
10222 
 
10223 
  def write(self, oprot):
10224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10226 
      return
10227 
    oprot.writeStructBegin('getOrdersInBatch_result')
10228 
    if self.success is not None:
10229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10231 
      for iter147 in self.success:
10232 
        iter147.write(oprot)
4133 chandransh 10233 
      oprot.writeListEnd()
10234 
      oprot.writeFieldEnd()
10235 
    if self.ex is not None:
10236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10237 
      self.ex.write(oprot)
10238 
      oprot.writeFieldEnd()
10239 
    oprot.writeFieldStop()
10240 
    oprot.writeStructEnd()
10241 
 
10242 
  def validate(self):
10243 
    return
10244 
 
10245 
 
10246 
  def __repr__(self):
10247 
    L = ['%s=%r' % (key, value)
10248 
      for key, value in self.__dict__.iteritems()]
10249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10250 
 
10251 
  def __eq__(self, other):
10252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10253 
 
10254 
  def __ne__(self, other):
10255 
    return not (self == other)
10256 
 
10257 
class getOrderCount_args:
10258 
  """
10259 
  Attributes:
10260 
   - statuses
10261 
   - warehouseId
10262 
  """
10263 
 
10264 
  thrift_spec = (
10265 
    None, # 0
10266 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10267 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10268 
  )
10269 
 
10270 
  def __init__(self, statuses=None, warehouseId=None,):
10271 
    self.statuses = statuses
10272 
    self.warehouseId = warehouseId
10273 
 
10274 
  def read(self, iprot):
10275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10277 
      return
10278 
    iprot.readStructBegin()
10279 
    while True:
10280 
      (fname, ftype, fid) = iprot.readFieldBegin()
10281 
      if ftype == TType.STOP:
10282 
        break
10283 
      if fid == 1:
10284 
        if ftype == TType.LIST:
10285 
          self.statuses = []
6188 rajveer 10286 
          (_etype151, _size148) = iprot.readListBegin()
10287 
          for _i152 in xrange(_size148):
10288 
            _elem153 = iprot.readI32();
10289 
            self.statuses.append(_elem153)
4133 chandransh 10290 
          iprot.readListEnd()
10291 
        else:
10292 
          iprot.skip(ftype)
10293 
      elif fid == 2:
10294 
        if ftype == TType.I64:
10295 
          self.warehouseId = iprot.readI64();
10296 
        else:
10297 
          iprot.skip(ftype)
10298 
      else:
10299 
        iprot.skip(ftype)
10300 
      iprot.readFieldEnd()
10301 
    iprot.readStructEnd()
10302 
 
10303 
  def write(self, oprot):
10304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10306 
      return
10307 
    oprot.writeStructBegin('getOrderCount_args')
10308 
    if self.statuses is not None:
10309 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10310 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10311 
      for iter154 in self.statuses:
10312 
        oprot.writeI32(iter154)
4133 chandransh 10313 
      oprot.writeListEnd()
10314 
      oprot.writeFieldEnd()
10315 
    if self.warehouseId is not None:
10316 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10317 
      oprot.writeI64(self.warehouseId)
10318 
      oprot.writeFieldEnd()
10319 
    oprot.writeFieldStop()
10320 
    oprot.writeStructEnd()
10321 
 
10322 
  def validate(self):
10323 
    return
10324 
 
10325 
 
10326 
  def __repr__(self):
10327 
    L = ['%s=%r' % (key, value)
10328 
      for key, value in self.__dict__.iteritems()]
10329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10330 
 
10331 
  def __eq__(self, other):
10332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10333 
 
10334 
  def __ne__(self, other):
10335 
    return not (self == other)
10336 
 
10337 
class getOrderCount_result:
10338 
  """
10339 
  Attributes:
10340 
   - success
10341 
   - ex
10342 
  """
10343 
 
10344 
  thrift_spec = (
10345 
    (0, TType.I32, 'success', None, None, ), # 0
10346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10347 
  )
10348 
 
10349 
  def __init__(self, success=None, ex=None,):
10350 
    self.success = success
10351 
    self.ex = ex
10352 
 
10353 
  def read(self, iprot):
10354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10356 
      return
10357 
    iprot.readStructBegin()
10358 
    while True:
10359 
      (fname, ftype, fid) = iprot.readFieldBegin()
10360 
      if ftype == TType.STOP:
10361 
        break
10362 
      if fid == 0:
10363 
        if ftype == TType.I32:
10364 
          self.success = iprot.readI32();
10365 
        else:
10366 
          iprot.skip(ftype)
10367 
      elif fid == 1:
10368 
        if ftype == TType.STRUCT:
10369 
          self.ex = TransactionServiceException()
10370 
          self.ex.read(iprot)
10371 
        else:
10372 
          iprot.skip(ftype)
10373 
      else:
10374 
        iprot.skip(ftype)
10375 
      iprot.readFieldEnd()
10376 
    iprot.readStructEnd()
10377 
 
10378 
  def write(self, oprot):
10379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10381 
      return
10382 
    oprot.writeStructBegin('getOrderCount_result')
10383 
    if self.success is not None:
10384 
      oprot.writeFieldBegin('success', TType.I32, 0)
10385 
      oprot.writeI32(self.success)
10386 
      oprot.writeFieldEnd()
10387 
    if self.ex is not None:
10388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10389 
      self.ex.write(oprot)
10390 
      oprot.writeFieldEnd()
10391 
    oprot.writeFieldStop()
10392 
    oprot.writeStructEnd()
10393 
 
10394 
  def validate(self):
10395 
    return
10396 
 
10397 
 
10398 
  def __repr__(self):
10399 
    L = ['%s=%r' % (key, value)
10400 
      for key, value in self.__dict__.iteritems()]
10401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10402 
 
10403 
  def __eq__(self, other):
10404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10405 
 
10406 
  def __ne__(self, other):
10407 
    return not (self == other)
10408 
 
999 varun.gupt 10409 
class getOrdersByBillingDate_args:
10410 
  """
10411 
  Attributes:
10412 
   - status
10413 
   - start_billing_date
10414 
   - end_billing_date
10415 
   - warehouse_id
10416 
  """
10417 
 
10418 
  thrift_spec = (
10419 
    None, # 0
10420 
    (1, TType.I32, 'status', None, None, ), # 1
10421 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10422 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10423 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10424 
  )
10425 
 
10426 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10427 
    self.status = status
10428 
    self.start_billing_date = start_billing_date
10429 
    self.end_billing_date = end_billing_date
10430 
    self.warehouse_id = warehouse_id
10431 
 
10432 
  def read(self, iprot):
10433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10435 
      return
10436 
    iprot.readStructBegin()
10437 
    while True:
10438 
      (fname, ftype, fid) = iprot.readFieldBegin()
10439 
      if ftype == TType.STOP:
10440 
        break
10441 
      if fid == 1:
10442 
        if ftype == TType.I32:
10443 
          self.status = iprot.readI32();
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      elif fid == 2:
10447 
        if ftype == TType.I64:
10448 
          self.start_billing_date = iprot.readI64();
10449 
        else:
10450 
          iprot.skip(ftype)
10451 
      elif fid == 3:
10452 
        if ftype == TType.I64:
10453 
          self.end_billing_date = iprot.readI64();
10454 
        else:
10455 
          iprot.skip(ftype)
10456 
      elif fid == 4:
10457 
        if ftype == TType.I64:
10458 
          self.warehouse_id = iprot.readI64();
10459 
        else:
10460 
          iprot.skip(ftype)
10461 
      else:
10462 
        iprot.skip(ftype)
10463 
      iprot.readFieldEnd()
10464 
    iprot.readStructEnd()
10465 
 
10466 
  def write(self, oprot):
10467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10469 
      return
10470 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10471 
    if self.status is not None:
999 varun.gupt 10472 
      oprot.writeFieldBegin('status', TType.I32, 1)
10473 
      oprot.writeI32(self.status)
10474 
      oprot.writeFieldEnd()
3431 rajveer 10475 
    if self.start_billing_date is not None:
999 varun.gupt 10476 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10477 
      oprot.writeI64(self.start_billing_date)
10478 
      oprot.writeFieldEnd()
3431 rajveer 10479 
    if self.end_billing_date is not None:
999 varun.gupt 10480 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10481 
      oprot.writeI64(self.end_billing_date)
10482 
      oprot.writeFieldEnd()
3431 rajveer 10483 
    if self.warehouse_id is not None:
999 varun.gupt 10484 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10485 
      oprot.writeI64(self.warehouse_id)
10486 
      oprot.writeFieldEnd()
10487 
    oprot.writeFieldStop()
10488 
    oprot.writeStructEnd()
10489 
 
3431 rajveer 10490 
  def validate(self):
10491 
    return
10492 
 
10493 
 
999 varun.gupt 10494 
  def __repr__(self):
10495 
    L = ['%s=%r' % (key, value)
10496 
      for key, value in self.__dict__.iteritems()]
10497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10498 
 
10499 
  def __eq__(self, other):
10500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10501 
 
10502 
  def __ne__(self, other):
10503 
    return not (self == other)
10504 
 
10505 
class getOrdersByBillingDate_result:
10506 
  """
10507 
  Attributes:
10508 
   - success
10509 
   - ex
10510 
  """
10511 
 
10512 
  thrift_spec = (
10513 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10515 
  )
10516 
 
10517 
  def __init__(self, success=None, ex=None,):
10518 
    self.success = success
10519 
    self.ex = ex
10520 
 
10521 
  def read(self, iprot):
10522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10524 
      return
10525 
    iprot.readStructBegin()
10526 
    while True:
10527 
      (fname, ftype, fid) = iprot.readFieldBegin()
10528 
      if ftype == TType.STOP:
10529 
        break
10530 
      if fid == 0:
10531 
        if ftype == TType.LIST:
10532 
          self.success = []
6188 rajveer 10533 
          (_etype158, _size155) = iprot.readListBegin()
10534 
          for _i159 in xrange(_size155):
10535 
            _elem160 = Order()
10536 
            _elem160.read(iprot)
10537 
            self.success.append(_elem160)
999 varun.gupt 10538 
          iprot.readListEnd()
10539 
        else:
10540 
          iprot.skip(ftype)
10541 
      elif fid == 1:
10542 
        if ftype == TType.STRUCT:
10543 
          self.ex = TransactionServiceException()
10544 
          self.ex.read(iprot)
10545 
        else:
10546 
          iprot.skip(ftype)
10547 
      else:
10548 
        iprot.skip(ftype)
10549 
      iprot.readFieldEnd()
10550 
    iprot.readStructEnd()
10551 
 
10552 
  def write(self, oprot):
10553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10555 
      return
10556 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10557 
    if self.success is not None:
999 varun.gupt 10558 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10559 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10560 
      for iter161 in self.success:
10561 
        iter161.write(oprot)
999 varun.gupt 10562 
      oprot.writeListEnd()
10563 
      oprot.writeFieldEnd()
3431 rajveer 10564 
    if self.ex is not None:
999 varun.gupt 10565 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10566 
      self.ex.write(oprot)
10567 
      oprot.writeFieldEnd()
10568 
    oprot.writeFieldStop()
10569 
    oprot.writeStructEnd()
10570 
 
3431 rajveer 10571 
  def validate(self):
10572 
    return
10573 
 
10574 
 
999 varun.gupt 10575 
  def __repr__(self):
10576 
    L = ['%s=%r' % (key, value)
10577 
      for key, value in self.__dict__.iteritems()]
10578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10579 
 
10580 
  def __eq__(self, other):
10581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10582 
 
10583 
  def __ne__(self, other):
10584 
    return not (self == other)
10585 
 
3427 chandransh 10586 
class getOrdersByShippingDate_args:
10587 
  """
10588 
  Attributes:
10589 
   - fromShippingDate
10590 
   - toShippingDate
10591 
   - providerId
10592 
   - warehouseId
3451 chandransh 10593 
   - cod
3427 chandransh 10594 
  """
10595 
 
10596 
  thrift_spec = (
10597 
    None, # 0
10598 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10599 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10600 
    (3, TType.I64, 'providerId', None, None, ), # 3
10601 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10602 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10603 
  )
10604 
 
3451 chandransh 10605 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10606 
    self.fromShippingDate = fromShippingDate
10607 
    self.toShippingDate = toShippingDate
10608 
    self.providerId = providerId
10609 
    self.warehouseId = warehouseId
3451 chandransh 10610 
    self.cod = cod
3427 chandransh 10611 
 
10612 
  def read(self, iprot):
10613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10615 
      return
10616 
    iprot.readStructBegin()
10617 
    while True:
10618 
      (fname, ftype, fid) = iprot.readFieldBegin()
10619 
      if ftype == TType.STOP:
10620 
        break
10621 
      if fid == 1:
10622 
        if ftype == TType.I64:
10623 
          self.fromShippingDate = iprot.readI64();
10624 
        else:
10625 
          iprot.skip(ftype)
10626 
      elif fid == 2:
10627 
        if ftype == TType.I64:
10628 
          self.toShippingDate = iprot.readI64();
10629 
        else:
10630 
          iprot.skip(ftype)
10631 
      elif fid == 3:
10632 
        if ftype == TType.I64:
10633 
          self.providerId = iprot.readI64();
10634 
        else:
10635 
          iprot.skip(ftype)
10636 
      elif fid == 4:
10637 
        if ftype == TType.I64:
10638 
          self.warehouseId = iprot.readI64();
10639 
        else:
10640 
          iprot.skip(ftype)
3451 chandransh 10641 
      elif fid == 5:
10642 
        if ftype == TType.BOOL:
10643 
          self.cod = iprot.readBool();
10644 
        else:
10645 
          iprot.skip(ftype)
3427 chandransh 10646 
      else:
10647 
        iprot.skip(ftype)
10648 
      iprot.readFieldEnd()
10649 
    iprot.readStructEnd()
10650 
 
10651 
  def write(self, oprot):
10652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10654 
      return
10655 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10656 
    if self.fromShippingDate is not None:
3427 chandransh 10657 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10658 
      oprot.writeI64(self.fromShippingDate)
10659 
      oprot.writeFieldEnd()
3431 rajveer 10660 
    if self.toShippingDate is not None:
3427 chandransh 10661 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10662 
      oprot.writeI64(self.toShippingDate)
10663 
      oprot.writeFieldEnd()
3431 rajveer 10664 
    if self.providerId is not None:
3427 chandransh 10665 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10666 
      oprot.writeI64(self.providerId)
10667 
      oprot.writeFieldEnd()
3431 rajveer 10668 
    if self.warehouseId is not None:
3427 chandransh 10669 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10670 
      oprot.writeI64(self.warehouseId)
10671 
      oprot.writeFieldEnd()
3451 chandransh 10672 
    if self.cod is not None:
10673 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10674 
      oprot.writeBool(self.cod)
10675 
      oprot.writeFieldEnd()
3427 chandransh 10676 
    oprot.writeFieldStop()
10677 
    oprot.writeStructEnd()
10678 
 
3431 rajveer 10679 
  def validate(self):
10680 
    return
10681 
 
10682 
 
3427 chandransh 10683 
  def __repr__(self):
10684 
    L = ['%s=%r' % (key, value)
10685 
      for key, value in self.__dict__.iteritems()]
10686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10687 
 
10688 
  def __eq__(self, other):
10689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10690 
 
10691 
  def __ne__(self, other):
10692 
    return not (self == other)
10693 
 
10694 
class getOrdersByShippingDate_result:
10695 
  """
10696 
  Attributes:
10697 
   - success
10698 
   - ex
10699 
  """
10700 
 
10701 
  thrift_spec = (
10702 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10704 
  )
10705 
 
10706 
  def __init__(self, success=None, ex=None,):
10707 
    self.success = success
10708 
    self.ex = ex
10709 
 
10710 
  def read(self, iprot):
10711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10713 
      return
10714 
    iprot.readStructBegin()
10715 
    while True:
10716 
      (fname, ftype, fid) = iprot.readFieldBegin()
10717 
      if ftype == TType.STOP:
10718 
        break
10719 
      if fid == 0:
10720 
        if ftype == TType.LIST:
10721 
          self.success = []
6188 rajveer 10722 
          (_etype165, _size162) = iprot.readListBegin()
10723 
          for _i166 in xrange(_size162):
10724 
            _elem167 = Order()
10725 
            _elem167.read(iprot)
10726 
            self.success.append(_elem167)
3427 chandransh 10727 
          iprot.readListEnd()
10728 
        else:
10729 
          iprot.skip(ftype)
10730 
      elif fid == 1:
10731 
        if ftype == TType.STRUCT:
10732 
          self.ex = TransactionServiceException()
10733 
          self.ex.read(iprot)
10734 
        else:
10735 
          iprot.skip(ftype)
10736 
      else:
10737 
        iprot.skip(ftype)
10738 
      iprot.readFieldEnd()
10739 
    iprot.readStructEnd()
10740 
 
10741 
  def write(self, oprot):
10742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10744 
      return
10745 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10746 
    if self.success is not None:
3427 chandransh 10747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10749 
      for iter168 in self.success:
10750 
        iter168.write(oprot)
3427 chandransh 10751 
      oprot.writeListEnd()
10752 
      oprot.writeFieldEnd()
3431 rajveer 10753 
    if self.ex is not None:
3427 chandransh 10754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10755 
      self.ex.write(oprot)
10756 
      oprot.writeFieldEnd()
10757 
    oprot.writeFieldStop()
10758 
    oprot.writeStructEnd()
10759 
 
3431 rajveer 10760 
  def validate(self):
10761 
    return
10762 
 
10763 
 
3427 chandransh 10764 
  def __repr__(self):
10765 
    L = ['%s=%r' % (key, value)
10766 
      for key, value in self.__dict__.iteritems()]
10767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10768 
 
10769 
  def __eq__(self, other):
10770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10771 
 
10772 
  def __ne__(self, other):
10773 
    return not (self == other)
10774 
 
1382 varun.gupt 10775 
class getReturnableOrdersForCustomer_args:
10776 
  """
10777 
  Attributes:
10778 
   - customer_id
10779 
   - limit
10780 
  """
10781 
 
10782 
  thrift_spec = (
10783 
    None, # 0
10784 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10785 
    (2, TType.I64, 'limit', None, None, ), # 2
10786 
  )
10787 
 
10788 
  def __init__(self, customer_id=None, limit=None,):
10789 
    self.customer_id = customer_id
10790 
    self.limit = limit
10791 
 
10792 
  def read(self, iprot):
10793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10795 
      return
10796 
    iprot.readStructBegin()
10797 
    while True:
10798 
      (fname, ftype, fid) = iprot.readFieldBegin()
10799 
      if ftype == TType.STOP:
10800 
        break
10801 
      if fid == 1:
10802 
        if ftype == TType.I64:
10803 
          self.customer_id = iprot.readI64();
10804 
        else:
10805 
          iprot.skip(ftype)
10806 
      elif fid == 2:
10807 
        if ftype == TType.I64:
10808 
          self.limit = iprot.readI64();
10809 
        else:
10810 
          iprot.skip(ftype)
10811 
      else:
10812 
        iprot.skip(ftype)
10813 
      iprot.readFieldEnd()
10814 
    iprot.readStructEnd()
10815 
 
10816 
  def write(self, oprot):
10817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10819 
      return
10820 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10821 
    if self.customer_id is not None:
1382 varun.gupt 10822 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10823 
      oprot.writeI64(self.customer_id)
10824 
      oprot.writeFieldEnd()
3431 rajveer 10825 
    if self.limit is not None:
1382 varun.gupt 10826 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10827 
      oprot.writeI64(self.limit)
10828 
      oprot.writeFieldEnd()
10829 
    oprot.writeFieldStop()
10830 
    oprot.writeStructEnd()
10831 
 
3431 rajveer 10832 
  def validate(self):
10833 
    return
10834 
 
10835 
 
1382 varun.gupt 10836 
  def __repr__(self):
10837 
    L = ['%s=%r' % (key, value)
10838 
      for key, value in self.__dict__.iteritems()]
10839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10840 
 
10841 
  def __eq__(self, other):
10842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10843 
 
10844 
  def __ne__(self, other):
10845 
    return not (self == other)
10846 
 
10847 
class getReturnableOrdersForCustomer_result:
10848 
  """
10849 
  Attributes:
10850 
   - success
10851 
   - ex
10852 
  """
10853 
 
10854 
  thrift_spec = (
10855 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10856 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10857 
  )
10858 
 
10859 
  def __init__(self, success=None, ex=None,):
10860 
    self.success = success
10861 
    self.ex = ex
10862 
 
10863 
  def read(self, iprot):
10864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10866 
      return
10867 
    iprot.readStructBegin()
10868 
    while True:
10869 
      (fname, ftype, fid) = iprot.readFieldBegin()
10870 
      if ftype == TType.STOP:
10871 
        break
10872 
      if fid == 0:
10873 
        if ftype == TType.LIST:
10874 
          self.success = []
6188 rajveer 10875 
          (_etype172, _size169) = iprot.readListBegin()
10876 
          for _i173 in xrange(_size169):
10877 
            _elem174 = iprot.readI64();
10878 
            self.success.append(_elem174)
1382 varun.gupt 10879 
          iprot.readListEnd()
10880 
        else:
10881 
          iprot.skip(ftype)
10882 
      elif fid == 1:
10883 
        if ftype == TType.STRUCT:
10884 
          self.ex = TransactionServiceException()
10885 
          self.ex.read(iprot)
10886 
        else:
10887 
          iprot.skip(ftype)
10888 
      else:
10889 
        iprot.skip(ftype)
10890 
      iprot.readFieldEnd()
10891 
    iprot.readStructEnd()
10892 
 
10893 
  def write(self, oprot):
10894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10896 
      return
10897 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10898 
    if self.success is not None:
1382 varun.gupt 10899 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10900 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10901 
      for iter175 in self.success:
10902 
        oprot.writeI64(iter175)
1382 varun.gupt 10903 
      oprot.writeListEnd()
10904 
      oprot.writeFieldEnd()
3431 rajveer 10905 
    if self.ex is not None:
1382 varun.gupt 10906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10907 
      self.ex.write(oprot)
10908 
      oprot.writeFieldEnd()
10909 
    oprot.writeFieldStop()
10910 
    oprot.writeStructEnd()
10911 
 
3431 rajveer 10912 
  def validate(self):
10913 
    return
10914 
 
10915 
 
1382 varun.gupt 10916 
  def __repr__(self):
10917 
    L = ['%s=%r' % (key, value)
10918 
      for key, value in self.__dict__.iteritems()]
10919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10920 
 
10921 
  def __eq__(self, other):
10922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10923 
 
10924 
  def __ne__(self, other):
10925 
    return not (self == other)
10926 
 
10927 
class getCancellableOrdersForCustomer_args:
10928 
  """
10929 
  Attributes:
10930 
   - customer_id
10931 
   - limit
10932 
  """
10933 
 
10934 
  thrift_spec = (
10935 
    None, # 0
10936 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10937 
    (2, TType.I64, 'limit', None, None, ), # 2
10938 
  )
10939 
 
10940 
  def __init__(self, customer_id=None, limit=None,):
10941 
    self.customer_id = customer_id
10942 
    self.limit = limit
10943 
 
10944 
  def read(self, iprot):
10945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10947 
      return
10948 
    iprot.readStructBegin()
10949 
    while True:
10950 
      (fname, ftype, fid) = iprot.readFieldBegin()
10951 
      if ftype == TType.STOP:
10952 
        break
10953 
      if fid == 1:
10954 
        if ftype == TType.I64:
10955 
          self.customer_id = iprot.readI64();
10956 
        else:
10957 
          iprot.skip(ftype)
10958 
      elif fid == 2:
10959 
        if ftype == TType.I64:
10960 
          self.limit = iprot.readI64();
10961 
        else:
10962 
          iprot.skip(ftype)
10963 
      else:
10964 
        iprot.skip(ftype)
10965 
      iprot.readFieldEnd()
10966 
    iprot.readStructEnd()
10967 
 
10968 
  def write(self, oprot):
10969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10971 
      return
10972 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10973 
    if self.customer_id is not None:
1382 varun.gupt 10974 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10975 
      oprot.writeI64(self.customer_id)
10976 
      oprot.writeFieldEnd()
3431 rajveer 10977 
    if self.limit is not None:
1382 varun.gupt 10978 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10979 
      oprot.writeI64(self.limit)
10980 
      oprot.writeFieldEnd()
10981 
    oprot.writeFieldStop()
10982 
    oprot.writeStructEnd()
10983 
 
3431 rajveer 10984 
  def validate(self):
10985 
    return
10986 
 
10987 
 
1382 varun.gupt 10988 
  def __repr__(self):
10989 
    L = ['%s=%r' % (key, value)
10990 
      for key, value in self.__dict__.iteritems()]
10991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10992 
 
10993 
  def __eq__(self, other):
10994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10995 
 
10996 
  def __ne__(self, other):
10997 
    return not (self == other)
10998 
 
10999 
class getCancellableOrdersForCustomer_result:
11000 
  """
11001 
  Attributes:
11002 
   - success
11003 
   - ex
11004 
  """
11005 
 
11006 
  thrift_spec = (
11007 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11009 
  )
11010 
 
11011 
  def __init__(self, success=None, ex=None,):
11012 
    self.success = success
11013 
    self.ex = ex
11014 
 
11015 
  def read(self, iprot):
11016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11018 
      return
11019 
    iprot.readStructBegin()
11020 
    while True:
11021 
      (fname, ftype, fid) = iprot.readFieldBegin()
11022 
      if ftype == TType.STOP:
11023 
        break
11024 
      if fid == 0:
11025 
        if ftype == TType.LIST:
11026 
          self.success = []
6188 rajveer 11027 
          (_etype179, _size176) = iprot.readListBegin()
11028 
          for _i180 in xrange(_size176):
11029 
            _elem181 = iprot.readI64();
11030 
            self.success.append(_elem181)
1382 varun.gupt 11031 
          iprot.readListEnd()
11032 
        else:
11033 
          iprot.skip(ftype)
11034 
      elif fid == 1:
11035 
        if ftype == TType.STRUCT:
11036 
          self.ex = TransactionServiceException()
11037 
          self.ex.read(iprot)
11038 
        else:
11039 
          iprot.skip(ftype)
11040 
      else:
11041 
        iprot.skip(ftype)
11042 
      iprot.readFieldEnd()
11043 
    iprot.readStructEnd()
11044 
 
11045 
  def write(self, oprot):
11046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11048 
      return
11049 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11050 
    if self.success is not None:
1382 varun.gupt 11051 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11052 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11053 
      for iter182 in self.success:
11054 
        oprot.writeI64(iter182)
1382 varun.gupt 11055 
      oprot.writeListEnd()
11056 
      oprot.writeFieldEnd()
3431 rajveer 11057 
    if self.ex is not None:
1382 varun.gupt 11058 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11059 
      self.ex.write(oprot)
11060 
      oprot.writeFieldEnd()
11061 
    oprot.writeFieldStop()
11062 
    oprot.writeStructEnd()
11063 
 
3431 rajveer 11064 
  def validate(self):
11065 
    return
11066 
 
11067 
 
1382 varun.gupt 11068 
  def __repr__(self):
11069 
    L = ['%s=%r' % (key, value)
11070 
      for key, value in self.__dict__.iteritems()]
11071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11072 
 
11073 
  def __eq__(self, other):
11074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11075 
 
11076 
  def __ne__(self, other):
11077 
    return not (self == other)
11078 
 
483 rajveer 11079 
class changeOrderStatus_args:
94 ashish 11080 
  """
11081 
  Attributes:
483 rajveer 11082 
   - orderId
11083 
   - status
11084 
   - description
94 ashish 11085 
  """
11086 
 
11087 
  thrift_spec = (
11088 
    None, # 0
483 rajveer 11089 
    (1, TType.I64, 'orderId', None, None, ), # 1
11090 
    (2, TType.I32, 'status', None, None, ), # 2
11091 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11092 
  )
11093 
 
483 rajveer 11094 
  def __init__(self, orderId=None, status=None, description=None,):
11095 
    self.orderId = orderId
11096 
    self.status = status
11097 
    self.description = description
94 ashish 11098 
 
11099 
  def read(self, iprot):
11100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11102 
      return
11103 
    iprot.readStructBegin()
11104 
    while True:
11105 
      (fname, ftype, fid) = iprot.readFieldBegin()
11106 
      if ftype == TType.STOP:
11107 
        break
11108 
      if fid == 1:
11109 
        if ftype == TType.I64:
483 rajveer 11110 
          self.orderId = iprot.readI64();
94 ashish 11111 
        else:
11112 
          iprot.skip(ftype)
11113 
      elif fid == 2:
483 rajveer 11114 
        if ftype == TType.I32:
11115 
          self.status = iprot.readI32();
94 ashish 11116 
        else:
11117 
          iprot.skip(ftype)
483 rajveer 11118 
      elif fid == 3:
11119 
        if ftype == TType.STRING:
11120 
          self.description = iprot.readString();
11121 
        else:
11122 
          iprot.skip(ftype)
94 ashish 11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
483 rajveer 11132 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11133 
    if self.orderId is not None:
483 rajveer 11134 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11135 
      oprot.writeI64(self.orderId)
94 ashish 11136 
      oprot.writeFieldEnd()
3431 rajveer 11137 
    if self.status is not None:
483 rajveer 11138 
      oprot.writeFieldBegin('status', TType.I32, 2)
11139 
      oprot.writeI32(self.status)
94 ashish 11140 
      oprot.writeFieldEnd()
3431 rajveer 11141 
    if self.description is not None:
483 rajveer 11142 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11143 
      oprot.writeString(self.description)
11144 
      oprot.writeFieldEnd()
94 ashish 11145 
    oprot.writeFieldStop()
11146 
    oprot.writeStructEnd()
11147 
 
3431 rajveer 11148 
  def validate(self):
11149 
    return
11150 
 
11151 
 
94 ashish 11152 
  def __repr__(self):
11153 
    L = ['%s=%r' % (key, value)
11154 
      for key, value in self.__dict__.iteritems()]
11155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11156 
 
11157 
  def __eq__(self, other):
11158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11159 
 
11160 
  def __ne__(self, other):
11161 
    return not (self == other)
11162 
 
483 rajveer 11163 
class changeOrderStatus_result:
94 ashish 11164 
  """
11165 
  Attributes:
11166 
   - success
11167 
   - ex
11168 
  """
11169 
 
11170 
  thrift_spec = (
11171 
    (0, TType.BOOL, 'success', None, None, ), # 0
11172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11173 
  )
11174 
 
11175 
  def __init__(self, success=None, ex=None,):
11176 
    self.success = success
11177 
    self.ex = ex
11178 
 
11179 
  def read(self, iprot):
11180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11182 
      return
11183 
    iprot.readStructBegin()
11184 
    while True:
11185 
      (fname, ftype, fid) = iprot.readFieldBegin()
11186 
      if ftype == TType.STOP:
11187 
        break
11188 
      if fid == 0:
11189 
        if ftype == TType.BOOL:
11190 
          self.success = iprot.readBool();
11191 
        else:
11192 
          iprot.skip(ftype)
11193 
      elif fid == 1:
11194 
        if ftype == TType.STRUCT:
11195 
          self.ex = TransactionServiceException()
11196 
          self.ex.read(iprot)
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      else:
11200 
        iprot.skip(ftype)
11201 
      iprot.readFieldEnd()
11202 
    iprot.readStructEnd()
11203 
 
11204 
  def write(self, oprot):
11205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11207 
      return
483 rajveer 11208 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11209 
    if self.success is not None:
94 ashish 11210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11211 
      oprot.writeBool(self.success)
11212 
      oprot.writeFieldEnd()
3431 rajveer 11213 
    if self.ex is not None:
94 ashish 11214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11215 
      self.ex.write(oprot)
11216 
      oprot.writeFieldEnd()
11217 
    oprot.writeFieldStop()
11218 
    oprot.writeStructEnd()
11219 
 
3431 rajveer 11220 
  def validate(self):
11221 
    return
11222 
 
11223 
 
94 ashish 11224 
  def __repr__(self):
11225 
    L = ['%s=%r' % (key, value)
11226 
      for key, value in self.__dict__.iteritems()]
11227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11228 
 
11229 
  def __eq__(self, other):
11230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11231 
 
11232 
  def __ne__(self, other):
11233 
    return not (self == other)
11234 
 
3064 chandransh 11235 
class getOrdersForTransaction_args:
494 rajveer 11236 
  """
11237 
  Attributes:
3064 chandransh 11238 
   - transactionId
11239 
   - customerId
494 rajveer 11240 
  """
11241 
 
11242 
  thrift_spec = (
11243 
    None, # 0
3064 chandransh 11244 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11245 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11246 
  )
11247 
 
3064 chandransh 11248 
  def __init__(self, transactionId=None, customerId=None,):
11249 
    self.transactionId = transactionId
11250 
    self.customerId = customerId
494 rajveer 11251 
 
11252 
  def read(self, iprot):
11253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11255 
      return
11256 
    iprot.readStructBegin()
11257 
    while True:
11258 
      (fname, ftype, fid) = iprot.readFieldBegin()
11259 
      if ftype == TType.STOP:
11260 
        break
11261 
      if fid == 1:
11262 
        if ftype == TType.I64:
3064 chandransh 11263 
          self.transactionId = iprot.readI64();
494 rajveer 11264 
        else:
11265 
          iprot.skip(ftype)
11266 
      elif fid == 2:
3064 chandransh 11267 
        if ftype == TType.I64:
11268 
          self.customerId = iprot.readI64();
494 rajveer 11269 
        else:
11270 
          iprot.skip(ftype)
11271 
      else:
11272 
        iprot.skip(ftype)
11273 
      iprot.readFieldEnd()
11274 
    iprot.readStructEnd()
11275 
 
11276 
  def write(self, oprot):
11277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11279 
      return
3064 chandransh 11280 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11281 
    if self.transactionId is not None:
3064 chandransh 11282 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11283 
      oprot.writeI64(self.transactionId)
494 rajveer 11284 
      oprot.writeFieldEnd()
3431 rajveer 11285 
    if self.customerId is not None:
3064 chandransh 11286 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11287 
      oprot.writeI64(self.customerId)
494 rajveer 11288 
      oprot.writeFieldEnd()
11289 
    oprot.writeFieldStop()
11290 
    oprot.writeStructEnd()
11291 
 
3431 rajveer 11292 
  def validate(self):
11293 
    return
11294 
 
11295 
 
494 rajveer 11296 
  def __repr__(self):
11297 
    L = ['%s=%r' % (key, value)
11298 
      for key, value in self.__dict__.iteritems()]
11299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11300 
 
11301 
  def __eq__(self, other):
11302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11303 
 
11304 
  def __ne__(self, other):
11305 
    return not (self == other)
11306 
 
3064 chandransh 11307 
class getOrdersForTransaction_result:
494 rajveer 11308 
  """
11309 
  Attributes:
11310 
   - success
11311 
   - ex
11312 
  """
11313 
 
11314 
  thrift_spec = (
3064 chandransh 11315 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11317 
  )
11318 
 
11319 
  def __init__(self, success=None, ex=None,):
11320 
    self.success = success
11321 
    self.ex = ex
11322 
 
11323 
  def read(self, iprot):
11324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11326 
      return
11327 
    iprot.readStructBegin()
11328 
    while True:
11329 
      (fname, ftype, fid) = iprot.readFieldBegin()
11330 
      if ftype == TType.STOP:
11331 
        break
11332 
      if fid == 0:
3064 chandransh 11333 
        if ftype == TType.LIST:
11334 
          self.success = []
6188 rajveer 11335 
          (_etype186, _size183) = iprot.readListBegin()
11336 
          for _i187 in xrange(_size183):
11337 
            _elem188 = Order()
11338 
            _elem188.read(iprot)
11339 
            self.success.append(_elem188)
3064 chandransh 11340 
          iprot.readListEnd()
494 rajveer 11341 
        else:
11342 
          iprot.skip(ftype)
11343 
      elif fid == 1:
11344 
        if ftype == TType.STRUCT:
11345 
          self.ex = TransactionServiceException()
11346 
          self.ex.read(iprot)
11347 
        else:
11348 
          iprot.skip(ftype)
11349 
      else:
11350 
        iprot.skip(ftype)
11351 
      iprot.readFieldEnd()
11352 
    iprot.readStructEnd()
11353 
 
11354 
  def write(self, oprot):
11355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11357 
      return
3064 chandransh 11358 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11359 
    if self.success is not None:
3064 chandransh 11360 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11361 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11362 
      for iter189 in self.success:
11363 
        iter189.write(oprot)
3064 chandransh 11364 
      oprot.writeListEnd()
494 rajveer 11365 
      oprot.writeFieldEnd()
3431 rajveer 11366 
    if self.ex is not None:
494 rajveer 11367 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11368 
      self.ex.write(oprot)
11369 
      oprot.writeFieldEnd()
11370 
    oprot.writeFieldStop()
11371 
    oprot.writeStructEnd()
11372 
 
3431 rajveer 11373 
  def validate(self):
11374 
    return
11375 
 
11376 
 
494 rajveer 11377 
  def __repr__(self):
11378 
    L = ['%s=%r' % (key, value)
11379 
      for key, value in self.__dict__.iteritems()]
11380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11381 
 
11382 
  def __eq__(self, other):
11383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11384 
 
11385 
  def __ne__(self, other):
11386 
    return not (self == other)
11387 
 
3064 chandransh 11388 
class getOrdersForCustomer_args:
1149 chandransh 11389 
  """
11390 
  Attributes:
3064 chandransh 11391 
   - customerId
11392 
   - from_date
11393 
   - to_date
11394 
   - statuses
1149 chandransh 11395 
  """
11396 
 
11397 
  thrift_spec = (
11398 
    None, # 0
3064 chandransh 11399 
    (1, TType.I64, 'customerId', None, None, ), # 1
11400 
    (2, TType.I64, 'from_date', None, None, ), # 2
11401 
    (3, TType.I64, 'to_date', None, None, ), # 3
11402 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11403 
  )
11404 
 
3064 chandransh 11405 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11406 
    self.customerId = customerId
11407 
    self.from_date = from_date
11408 
    self.to_date = to_date
11409 
    self.statuses = statuses
1149 chandransh 11410 
 
11411 
  def read(self, iprot):
11412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11414 
      return
11415 
    iprot.readStructBegin()
11416 
    while True:
11417 
      (fname, ftype, fid) = iprot.readFieldBegin()
11418 
      if ftype == TType.STOP:
11419 
        break
11420 
      if fid == 1:
11421 
        if ftype == TType.I64:
3064 chandransh 11422 
          self.customerId = iprot.readI64();
1149 chandransh 11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      elif fid == 2:
11426 
        if ftype == TType.I64:
3064 chandransh 11427 
          self.from_date = iprot.readI64();
1149 chandransh 11428 
        else:
11429 
          iprot.skip(ftype)
2783 chandransh 11430 
      elif fid == 3:
11431 
        if ftype == TType.I64:
3064 chandransh 11432 
          self.to_date = iprot.readI64();
2783 chandransh 11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      elif fid == 4:
3064 chandransh 11436 
        if ftype == TType.LIST:
11437 
          self.statuses = []
6188 rajveer 11438 
          (_etype193, _size190) = iprot.readListBegin()
11439 
          for _i194 in xrange(_size190):
11440 
            _elem195 = iprot.readI32();
11441 
            self.statuses.append(_elem195)
3064 chandransh 11442 
          iprot.readListEnd()
2783 chandransh 11443 
        else:
11444 
          iprot.skip(ftype)
1149 chandransh 11445 
      else:
11446 
        iprot.skip(ftype)
11447 
      iprot.readFieldEnd()
11448 
    iprot.readStructEnd()
11449 
 
11450 
  def write(self, oprot):
11451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11453 
      return
3064 chandransh 11454 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11455 
    if self.customerId is not None:
3064 chandransh 11456 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11457 
      oprot.writeI64(self.customerId)
1149 chandransh 11458 
      oprot.writeFieldEnd()
3431 rajveer 11459 
    if self.from_date is not None:
3064 chandransh 11460 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11461 
      oprot.writeI64(self.from_date)
1149 chandransh 11462 
      oprot.writeFieldEnd()
3431 rajveer 11463 
    if self.to_date is not None:
3064 chandransh 11464 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11465 
      oprot.writeI64(self.to_date)
2783 chandransh 11466 
      oprot.writeFieldEnd()
3431 rajveer 11467 
    if self.statuses is not None:
3064 chandransh 11468 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11469 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11470 
      for iter196 in self.statuses:
11471 
        oprot.writeI32(iter196)
3064 chandransh 11472 
      oprot.writeListEnd()
2783 chandransh 11473 
      oprot.writeFieldEnd()
1149 chandransh 11474 
    oprot.writeFieldStop()
11475 
    oprot.writeStructEnd()
11476 
 
3431 rajveer 11477 
  def validate(self):
11478 
    return
11479 
 
11480 
 
1149 chandransh 11481 
  def __repr__(self):
11482 
    L = ['%s=%r' % (key, value)
11483 
      for key, value in self.__dict__.iteritems()]
11484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11485 
 
11486 
  def __eq__(self, other):
11487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11488 
 
11489 
  def __ne__(self, other):
11490 
    return not (self == other)
11491 
 
3064 chandransh 11492 
class getOrdersForCustomer_result:
1149 chandransh 11493 
  """
11494 
  Attributes:
11495 
   - success
11496 
   - ex
11497 
  """
11498 
 
11499 
  thrift_spec = (
3064 chandransh 11500 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11501 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11502 
  )
11503 
 
11504 
  def __init__(self, success=None, ex=None,):
11505 
    self.success = success
11506 
    self.ex = ex
11507 
 
11508 
  def read(self, iprot):
11509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11511 
      return
11512 
    iprot.readStructBegin()
11513 
    while True:
11514 
      (fname, ftype, fid) = iprot.readFieldBegin()
11515 
      if ftype == TType.STOP:
11516 
        break
11517 
      if fid == 0:
3064 chandransh 11518 
        if ftype == TType.LIST:
11519 
          self.success = []
6188 rajveer 11520 
          (_etype200, _size197) = iprot.readListBegin()
11521 
          for _i201 in xrange(_size197):
11522 
            _elem202 = Order()
11523 
            _elem202.read(iprot)
11524 
            self.success.append(_elem202)
3064 chandransh 11525 
          iprot.readListEnd()
1149 chandransh 11526 
        else:
11527 
          iprot.skip(ftype)
11528 
      elif fid == 1:
11529 
        if ftype == TType.STRUCT:
11530 
          self.ex = TransactionServiceException()
11531 
          self.ex.read(iprot)
11532 
        else:
11533 
          iprot.skip(ftype)
11534 
      else:
11535 
        iprot.skip(ftype)
11536 
      iprot.readFieldEnd()
11537 
    iprot.readStructEnd()
11538 
 
11539 
  def write(self, oprot):
11540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11542 
      return
3064 chandransh 11543 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11544 
    if self.success is not None:
3064 chandransh 11545 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11546 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11547 
      for iter203 in self.success:
11548 
        iter203.write(oprot)
3064 chandransh 11549 
      oprot.writeListEnd()
1149 chandransh 11550 
      oprot.writeFieldEnd()
3431 rajveer 11551 
    if self.ex is not None:
1149 chandransh 11552 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11553 
      self.ex.write(oprot)
11554 
      oprot.writeFieldEnd()
11555 
    oprot.writeFieldStop()
11556 
    oprot.writeStructEnd()
11557 
 
3431 rajveer 11558 
  def validate(self):
11559 
    return
11560 
 
11561 
 
1149 chandransh 11562 
  def __repr__(self):
11563 
    L = ['%s=%r' % (key, value)
11564 
      for key, value in self.__dict__.iteritems()]
11565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11566 
 
11567 
  def __eq__(self, other):
11568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11569 
 
11570 
  def __ne__(self, other):
11571 
    return not (self == other)
11572 
 
3064 chandransh 11573 
class createOrder_args:
921 rajveer 11574 
  """
11575 
  Attributes:
3064 chandransh 11576 
   - order
921 rajveer 11577 
  """
11578 
 
11579 
  thrift_spec = (
11580 
    None, # 0
3064 chandransh 11581 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11582 
  )
11583 
 
3064 chandransh 11584 
  def __init__(self, order=None,):
11585 
    self.order = order
921 rajveer 11586 
 
11587 
  def read(self, iprot):
11588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11590 
      return
11591 
    iprot.readStructBegin()
11592 
    while True:
11593 
      (fname, ftype, fid) = iprot.readFieldBegin()
11594 
      if ftype == TType.STOP:
11595 
        break
11596 
      if fid == 1:
3064 chandransh 11597 
        if ftype == TType.STRUCT:
11598 
          self.order = Order()
11599 
          self.order.read(iprot)
921 rajveer 11600 
        else:
11601 
          iprot.skip(ftype)
11602 
      else:
11603 
        iprot.skip(ftype)
11604 
      iprot.readFieldEnd()
11605 
    iprot.readStructEnd()
11606 
 
11607 
  def write(self, oprot):
11608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11610 
      return
3064 chandransh 11611 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11612 
    if self.order is not None:
3064 chandransh 11613 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11614 
      self.order.write(oprot)
921 rajveer 11615 
      oprot.writeFieldEnd()
11616 
    oprot.writeFieldStop()
11617 
    oprot.writeStructEnd()
11618 
 
3431 rajveer 11619 
  def validate(self):
11620 
    return
11621 
 
11622 
 
921 rajveer 11623 
  def __repr__(self):
11624 
    L = ['%s=%r' % (key, value)
11625 
      for key, value in self.__dict__.iteritems()]
11626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11627 
 
11628 
  def __eq__(self, other):
11629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11630 
 
11631 
  def __ne__(self, other):
11632 
    return not (self == other)
11633 
 
3064 chandransh 11634 
class createOrder_result:
921 rajveer 11635 
  """
11636 
  Attributes:
11637 
   - success
11638 
   - ex
11639 
  """
11640 
 
11641 
  thrift_spec = (
3064 chandransh 11642 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11644 
  )
11645 
 
11646 
  def __init__(self, success=None, ex=None,):
11647 
    self.success = success
11648 
    self.ex = ex
11649 
 
11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
11659 
      if fid == 0:
3064 chandransh 11660 
        if ftype == TType.I64:
11661 
          self.success = iprot.readI64();
921 rajveer 11662 
        else:
11663 
          iprot.skip(ftype)
11664 
      elif fid == 1:
11665 
        if ftype == TType.STRUCT:
11666 
          self.ex = TransactionServiceException()
11667 
          self.ex.read(iprot)
11668 
        else:
11669 
          iprot.skip(ftype)
11670 
      else:
11671 
        iprot.skip(ftype)
11672 
      iprot.readFieldEnd()
11673 
    iprot.readStructEnd()
11674 
 
11675 
  def write(self, oprot):
11676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11678 
      return
3064 chandransh 11679 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11680 
    if self.success is not None:
3064 chandransh 11681 
      oprot.writeFieldBegin('success', TType.I64, 0)
11682 
      oprot.writeI64(self.success)
921 rajveer 11683 
      oprot.writeFieldEnd()
3431 rajveer 11684 
    if self.ex is not None:
921 rajveer 11685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11686 
      self.ex.write(oprot)
11687 
      oprot.writeFieldEnd()
11688 
    oprot.writeFieldStop()
11689 
    oprot.writeStructEnd()
11690 
 
3431 rajveer 11691 
  def validate(self):
11692 
    return
11693 
 
11694 
 
921 rajveer 11695 
  def __repr__(self):
11696 
    L = ['%s=%r' % (key, value)
11697 
      for key, value in self.__dict__.iteritems()]
11698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11699 
 
11700 
  def __eq__(self, other):
11701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11702 
 
11703 
  def __ne__(self, other):
11704 
    return not (self == other)
11705 
 
3064 chandransh 11706 
class getOrder_args:
921 rajveer 11707 
  """
11708 
  Attributes:
3064 chandransh 11709 
   - id
921 rajveer 11710 
  """
11711 
 
11712 
  thrift_spec = (
11713 
    None, # 0
3064 chandransh 11714 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11715 
  )
11716 
 
3064 chandransh 11717 
  def __init__(self, id=None,):
11718 
    self.id = id
921 rajveer 11719 
 
11720 
  def read(self, iprot):
11721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11723 
      return
11724 
    iprot.readStructBegin()
11725 
    while True:
11726 
      (fname, ftype, fid) = iprot.readFieldBegin()
11727 
      if ftype == TType.STOP:
11728 
        break
11729 
      if fid == 1:
11730 
        if ftype == TType.I64:
3064 chandransh 11731 
          self.id = iprot.readI64();
921 rajveer 11732 
        else:
11733 
          iprot.skip(ftype)
11734 
      else:
11735 
        iprot.skip(ftype)
11736 
      iprot.readFieldEnd()
11737 
    iprot.readStructEnd()
11738 
 
11739 
  def write(self, oprot):
11740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11742 
      return
3064 chandransh 11743 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11744 
    if self.id is not None:
3064 chandransh 11745 
      oprot.writeFieldBegin('id', TType.I64, 1)
11746 
      oprot.writeI64(self.id)
921 rajveer 11747 
      oprot.writeFieldEnd()
11748 
    oprot.writeFieldStop()
11749 
    oprot.writeStructEnd()
11750 
 
3431 rajveer 11751 
  def validate(self):
11752 
    return
11753 
 
11754 
 
921 rajveer 11755 
  def __repr__(self):
11756 
    L = ['%s=%r' % (key, value)
11757 
      for key, value in self.__dict__.iteritems()]
11758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11759 
 
11760 
  def __eq__(self, other):
11761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11762 
 
11763 
  def __ne__(self, other):
11764 
    return not (self == other)
11765 
 
3064 chandransh 11766 
class getOrder_result:
921 rajveer 11767 
  """
11768 
  Attributes:
11769 
   - success
11770 
   - ex
11771 
  """
11772 
 
11773 
  thrift_spec = (
3064 chandransh 11774 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11776 
  )
11777 
 
11778 
  def __init__(self, success=None, ex=None,):
11779 
    self.success = success
11780 
    self.ex = ex
11781 
 
11782 
  def read(self, iprot):
11783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11785 
      return
11786 
    iprot.readStructBegin()
11787 
    while True:
11788 
      (fname, ftype, fid) = iprot.readFieldBegin()
11789 
      if ftype == TType.STOP:
11790 
        break
11791 
      if fid == 0:
3064 chandransh 11792 
        if ftype == TType.STRUCT:
11793 
          self.success = Order()
11794 
          self.success.read(iprot)
921 rajveer 11795 
        else:
11796 
          iprot.skip(ftype)
11797 
      elif fid == 1:
11798 
        if ftype == TType.STRUCT:
11799 
          self.ex = TransactionServiceException()
11800 
          self.ex.read(iprot)
11801 
        else:
11802 
          iprot.skip(ftype)
11803 
      else:
11804 
        iprot.skip(ftype)
11805 
      iprot.readFieldEnd()
11806 
    iprot.readStructEnd()
11807 
 
11808 
  def write(self, oprot):
11809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11811 
      return
3064 chandransh 11812 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11813 
    if self.success is not None:
3064 chandransh 11814 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11815 
      self.success.write(oprot)
921 rajveer 11816 
      oprot.writeFieldEnd()
3431 rajveer 11817 
    if self.ex is not None:
921 rajveer 11818 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11819 
      self.ex.write(oprot)
11820 
      oprot.writeFieldEnd()
11821 
    oprot.writeFieldStop()
11822 
    oprot.writeStructEnd()
11823 
 
3431 rajveer 11824 
  def validate(self):
11825 
    return
11826 
 
11827 
 
921 rajveer 11828 
  def __repr__(self):
11829 
    L = ['%s=%r' % (key, value)
11830 
      for key, value in self.__dict__.iteritems()]
11831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11832 
 
11833 
  def __eq__(self, other):
11834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11835 
 
11836 
  def __ne__(self, other):
11837 
    return not (self == other)
11838 
 
3064 chandransh 11839 
class getLineItemsForOrder_args:
94 ashish 11840 
  """
11841 
  Attributes:
3064 chandransh 11842 
   - orderId
94 ashish 11843 
  """
11844 
 
11845 
  thrift_spec = (
11846 
    None, # 0
3064 chandransh 11847 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11848 
  )
11849 
 
3064 chandransh 11850 
  def __init__(self, orderId=None,):
11851 
    self.orderId = orderId
94 ashish 11852 
 
11853 
  def read(self, iprot):
11854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11856 
      return
11857 
    iprot.readStructBegin()
11858 
    while True:
11859 
      (fname, ftype, fid) = iprot.readFieldBegin()
11860 
      if ftype == TType.STOP:
11861 
        break
11862 
      if fid == 1:
11863 
        if ftype == TType.I64:
3064 chandransh 11864 
          self.orderId = iprot.readI64();
94 ashish 11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      else:
11868 
        iprot.skip(ftype)
11869 
      iprot.readFieldEnd()
11870 
    iprot.readStructEnd()
11871 
 
11872 
  def write(self, oprot):
11873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11875 
      return
3064 chandransh 11876 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11877 
    if self.orderId is not None:
3064 chandransh 11878 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11879 
      oprot.writeI64(self.orderId)
94 ashish 11880 
      oprot.writeFieldEnd()
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
3431 rajveer 11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
94 ashish 11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
3064 chandransh 11899 
class getLineItemsForOrder_result:
94 ashish 11900 
  """
11901 
  Attributes:
11902 
   - success
11903 
   - ex
11904 
  """
11905 
 
11906 
  thrift_spec = (
3064 chandransh 11907 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11908 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11909 
  )
11910 
 
11911 
  def __init__(self, success=None, ex=None,):
11912 
    self.success = success
11913 
    self.ex = ex
11914 
 
11915 
  def read(self, iprot):
11916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11918 
      return
11919 
    iprot.readStructBegin()
11920 
    while True:
11921 
      (fname, ftype, fid) = iprot.readFieldBegin()
11922 
      if ftype == TType.STOP:
11923 
        break
11924 
      if fid == 0:
483 rajveer 11925 
        if ftype == TType.LIST:
11926 
          self.success = []
6188 rajveer 11927 
          (_etype207, _size204) = iprot.readListBegin()
11928 
          for _i208 in xrange(_size204):
11929 
            _elem209 = LineItem()
11930 
            _elem209.read(iprot)
11931 
            self.success.append(_elem209)
483 rajveer 11932 
          iprot.readListEnd()
94 ashish 11933 
        else:
11934 
          iprot.skip(ftype)
11935 
      elif fid == 1:
11936 
        if ftype == TType.STRUCT:
11937 
          self.ex = TransactionServiceException()
11938 
          self.ex.read(iprot)
11939 
        else:
11940 
          iprot.skip(ftype)
11941 
      else:
11942 
        iprot.skip(ftype)
11943 
      iprot.readFieldEnd()
11944 
    iprot.readStructEnd()
11945 
 
11946 
  def write(self, oprot):
11947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11949 
      return
3064 chandransh 11950 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11951 
    if self.success is not None:
483 rajveer 11952 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11953 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11954 
      for iter210 in self.success:
11955 
        iter210.write(oprot)
483 rajveer 11956 
      oprot.writeListEnd()
94 ashish 11957 
      oprot.writeFieldEnd()
3431 rajveer 11958 
    if self.ex is not None:
94 ashish 11959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11960 
      self.ex.write(oprot)
11961 
      oprot.writeFieldEnd()
11962 
    oprot.writeFieldStop()
11963 
    oprot.writeStructEnd()
11964 
 
3431 rajveer 11965 
  def validate(self):
11966 
    return
11967 
 
11968 
 
94 ashish 11969 
  def __repr__(self):
11970 
    L = ['%s=%r' % (key, value)
11971 
      for key, value in self.__dict__.iteritems()]
11972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11973 
 
11974 
  def __eq__(self, other):
11975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11976 
 
11977 
  def __ne__(self, other):
11978 
    return not (self == other)
11979 
 
4999 phani.kuma 11980 
class getOrderList_args:
11981 
  """
11982 
  Attributes:
11983 
   - order_ids
11984 
  """
11985 
 
11986 
  thrift_spec = (
11987 
    None, # 0
11988 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11989 
  )
11990 
 
11991 
  def __init__(self, order_ids=None,):
11992 
    self.order_ids = order_ids
11993 
 
11994 
  def read(self, iprot):
11995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11997 
      return
11998 
    iprot.readStructBegin()
11999 
    while True:
12000 
      (fname, ftype, fid) = iprot.readFieldBegin()
12001 
      if ftype == TType.STOP:
12002 
        break
12003 
      if fid == 1:
12004 
        if ftype == TType.LIST:
12005 
          self.order_ids = []
6188 rajveer 12006 
          (_etype214, _size211) = iprot.readListBegin()
12007 
          for _i215 in xrange(_size211):
12008 
            _elem216 = iprot.readI64();
12009 
            self.order_ids.append(_elem216)
4999 phani.kuma 12010 
          iprot.readListEnd()
12011 
        else:
12012 
          iprot.skip(ftype)
12013 
      else:
12014 
        iprot.skip(ftype)
12015 
      iprot.readFieldEnd()
12016 
    iprot.readStructEnd()
12017 
 
12018 
  def write(self, oprot):
12019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12021 
      return
12022 
    oprot.writeStructBegin('getOrderList_args')
12023 
    if self.order_ids is not None:
12024 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12025 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12026 
      for iter217 in self.order_ids:
12027 
        oprot.writeI64(iter217)
4999 phani.kuma 12028 
      oprot.writeListEnd()
12029 
      oprot.writeFieldEnd()
12030 
    oprot.writeFieldStop()
12031 
    oprot.writeStructEnd()
12032 
 
12033 
  def validate(self):
12034 
    return
12035 
 
12036 
 
12037 
  def __repr__(self):
12038 
    L = ['%s=%r' % (key, value)
12039 
      for key, value in self.__dict__.iteritems()]
12040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12041 
 
12042 
  def __eq__(self, other):
12043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12044 
 
12045 
  def __ne__(self, other):
12046 
    return not (self == other)
12047 
 
12048 
class getOrderList_result:
12049 
  """
12050 
  Attributes:
12051 
   - success
12052 
  """
12053 
 
12054 
  thrift_spec = (
12055 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12056 
  )
12057 
 
12058 
  def __init__(self, success=None,):
12059 
    self.success = success
12060 
 
12061 
  def read(self, iprot):
12062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12064 
      return
12065 
    iprot.readStructBegin()
12066 
    while True:
12067 
      (fname, ftype, fid) = iprot.readFieldBegin()
12068 
      if ftype == TType.STOP:
12069 
        break
12070 
      if fid == 0:
12071 
        if ftype == TType.LIST:
12072 
          self.success = []
6188 rajveer 12073 
          (_etype221, _size218) = iprot.readListBegin()
12074 
          for _i222 in xrange(_size218):
12075 
            _elem223 = Order()
12076 
            _elem223.read(iprot)
12077 
            self.success.append(_elem223)
4999 phani.kuma 12078 
          iprot.readListEnd()
12079 
        else:
12080 
          iprot.skip(ftype)
12081 
      else:
12082 
        iprot.skip(ftype)
12083 
      iprot.readFieldEnd()
12084 
    iprot.readStructEnd()
12085 
 
12086 
  def write(self, oprot):
12087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12089 
      return
12090 
    oprot.writeStructBegin('getOrderList_result')
12091 
    if self.success is not None:
12092 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12093 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12094 
      for iter224 in self.success:
12095 
        iter224.write(oprot)
4999 phani.kuma 12096 
      oprot.writeListEnd()
12097 
      oprot.writeFieldEnd()
12098 
    oprot.writeFieldStop()
12099 
    oprot.writeStructEnd()
12100 
 
12101 
  def validate(self):
12102 
    return
12103 
 
12104 
 
12105 
  def __repr__(self):
12106 
    L = ['%s=%r' % (key, value)
12107 
      for key, value in self.__dict__.iteritems()]
12108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12109 
 
12110 
  def __eq__(self, other):
12111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12112 
 
12113 
  def __ne__(self, other):
12114 
    return not (self == other)
12115 
 
5386 phani.kuma 12116 
class getOrderListForVendor_args:
12117 
  """
12118 
  Attributes:
12119 
   - order_ids
12120 
   - vendorId
12121 
  """
12122 
 
12123 
  thrift_spec = (
12124 
    None, # 0
12125 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12126 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12127 
  )
12128 
 
12129 
  def __init__(self, order_ids=None, vendorId=None,):
12130 
    self.order_ids = order_ids
12131 
    self.vendorId = vendorId
12132 
 
12133 
  def read(self, iprot):
12134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12136 
      return
12137 
    iprot.readStructBegin()
12138 
    while True:
12139 
      (fname, ftype, fid) = iprot.readFieldBegin()
12140 
      if ftype == TType.STOP:
12141 
        break
12142 
      if fid == 1:
12143 
        if ftype == TType.LIST:
12144 
          self.order_ids = []
6188 rajveer 12145 
          (_etype228, _size225) = iprot.readListBegin()
12146 
          for _i229 in xrange(_size225):
12147 
            _elem230 = iprot.readI64();
12148 
            self.order_ids.append(_elem230)
5386 phani.kuma 12149 
          iprot.readListEnd()
12150 
        else:
12151 
          iprot.skip(ftype)
12152 
      elif fid == 2:
12153 
        if ftype == TType.I64:
12154 
          self.vendorId = iprot.readI64();
12155 
        else:
12156 
          iprot.skip(ftype)
12157 
      else:
12158 
        iprot.skip(ftype)
12159 
      iprot.readFieldEnd()
12160 
    iprot.readStructEnd()
12161 
 
12162 
  def write(self, oprot):
12163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12165 
      return
12166 
    oprot.writeStructBegin('getOrderListForVendor_args')
12167 
    if self.order_ids is not None:
12168 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12169 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12170 
      for iter231 in self.order_ids:
12171 
        oprot.writeI64(iter231)
5386 phani.kuma 12172 
      oprot.writeListEnd()
12173 
      oprot.writeFieldEnd()
12174 
    if self.vendorId is not None:
12175 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12176 
      oprot.writeI64(self.vendorId)
12177 
      oprot.writeFieldEnd()
12178 
    oprot.writeFieldStop()
12179 
    oprot.writeStructEnd()
12180 
 
12181 
  def validate(self):
12182 
    return
12183 
 
12184 
 
12185 
  def __repr__(self):
12186 
    L = ['%s=%r' % (key, value)
12187 
      for key, value in self.__dict__.iteritems()]
12188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12189 
 
12190 
  def __eq__(self, other):
12191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12192 
 
12193 
  def __ne__(self, other):
12194 
    return not (self == other)
12195 
 
12196 
class getOrderListForVendor_result:
12197 
  """
12198 
  Attributes:
12199 
   - success
12200 
  """
12201 
 
12202 
  thrift_spec = (
12203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12204 
  )
12205 
 
12206 
  def __init__(self, success=None,):
12207 
    self.success = success
12208 
 
12209 
  def read(self, iprot):
12210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12212 
      return
12213 
    iprot.readStructBegin()
12214 
    while True:
12215 
      (fname, ftype, fid) = iprot.readFieldBegin()
12216 
      if ftype == TType.STOP:
12217 
        break
12218 
      if fid == 0:
12219 
        if ftype == TType.LIST:
12220 
          self.success = []
6188 rajveer 12221 
          (_etype235, _size232) = iprot.readListBegin()
12222 
          for _i236 in xrange(_size232):
12223 
            _elem237 = Order()
12224 
            _elem237.read(iprot)
12225 
            self.success.append(_elem237)
5386 phani.kuma 12226 
          iprot.readListEnd()
12227 
        else:
12228 
          iprot.skip(ftype)
12229 
      else:
12230 
        iprot.skip(ftype)
12231 
      iprot.readFieldEnd()
12232 
    iprot.readStructEnd()
12233 
 
12234 
  def write(self, oprot):
12235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12237 
      return
12238 
    oprot.writeStructBegin('getOrderListForVendor_result')
12239 
    if self.success is not None:
12240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12241 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12242 
      for iter238 in self.success:
12243 
        iter238.write(oprot)
5386 phani.kuma 12244 
      oprot.writeListEnd()
12245 
      oprot.writeFieldEnd()
12246 
    oprot.writeFieldStop()
12247 
    oprot.writeStructEnd()
12248 
 
12249 
  def validate(self):
12250 
    return
12251 
 
12252 
 
12253 
  def __repr__(self):
12254 
    L = ['%s=%r' % (key, value)
12255 
      for key, value in self.__dict__.iteritems()]
12256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12257 
 
12258 
  def __eq__(self, other):
12259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12260 
 
12261 
  def __ne__(self, other):
12262 
    return not (self == other)
12263 
 
3064 chandransh 12264 
class getOrderForCustomer_args:
94 ashish 12265 
  """
12266 
  Attributes:
3064 chandransh 12267 
   - orderId
483 rajveer 12268 
   - customerId
94 ashish 12269 
  """
12270 
 
12271 
  thrift_spec = (
12272 
    None, # 0
3064 chandransh 12273 
    (1, TType.I64, 'orderId', None, None, ), # 1
12274 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12275 
  )
12276 
 
3064 chandransh 12277 
  def __init__(self, orderId=None, customerId=None,):
12278 
    self.orderId = orderId
483 rajveer 12279 
    self.customerId = customerId
94 ashish 12280 
 
12281 
  def read(self, iprot):
12282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12284 
      return
12285 
    iprot.readStructBegin()
12286 
    while True:
12287 
      (fname, ftype, fid) = iprot.readFieldBegin()
12288 
      if ftype == TType.STOP:
12289 
        break
12290 
      if fid == 1:
12291 
        if ftype == TType.I64:
3064 chandransh 12292 
          self.orderId = iprot.readI64();
94 ashish 12293 
        else:
12294 
          iprot.skip(ftype)
12295 
      elif fid == 2:
12296 
        if ftype == TType.I64:
3064 chandransh 12297 
          self.customerId = iprot.readI64();
94 ashish 12298 
        else:
12299 
          iprot.skip(ftype)
12300 
      else:
12301 
        iprot.skip(ftype)
12302 
      iprot.readFieldEnd()
12303 
    iprot.readStructEnd()
12304 
 
12305 
  def write(self, oprot):
12306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12308 
      return
3064 chandransh 12309 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12310 
    if self.orderId is not None:
3064 chandransh 12311 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12312 
      oprot.writeI64(self.orderId)
12313 
      oprot.writeFieldEnd()
3431 rajveer 12314 
    if self.customerId is not None:
3064 chandransh 12315 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12316 
      oprot.writeI64(self.customerId)
94 ashish 12317 
      oprot.writeFieldEnd()
12318 
    oprot.writeFieldStop()
12319 
    oprot.writeStructEnd()
12320 
 
3431 rajveer 12321 
  def validate(self):
12322 
    return
12323 
 
12324 
 
94 ashish 12325 
  def __repr__(self):
12326 
    L = ['%s=%r' % (key, value)
12327 
      for key, value in self.__dict__.iteritems()]
12328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12329 
 
12330 
  def __eq__(self, other):
12331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12332 
 
12333 
  def __ne__(self, other):
12334 
    return not (self == other)
12335 
 
3064 chandransh 12336 
class getOrderForCustomer_result:
94 ashish 12337 
  """
12338 
  Attributes:
12339 
   - success
12340 
   - ex
12341 
  """
12342 
 
12343 
  thrift_spec = (
3064 chandransh 12344 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12345 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12346 
  )
12347 
 
12348 
  def __init__(self, success=None, ex=None,):
12349 
    self.success = success
12350 
    self.ex = ex
12351 
 
12352 
  def read(self, iprot):
12353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12355 
      return
12356 
    iprot.readStructBegin()
12357 
    while True:
12358 
      (fname, ftype, fid) = iprot.readFieldBegin()
12359 
      if ftype == TType.STOP:
12360 
        break
12361 
      if fid == 0:
3064 chandransh 12362 
        if ftype == TType.STRUCT:
12363 
          self.success = Order()
12364 
          self.success.read(iprot)
94 ashish 12365 
        else:
12366 
          iprot.skip(ftype)
12367 
      elif fid == 1:
12368 
        if ftype == TType.STRUCT:
12369 
          self.ex = TransactionServiceException()
12370 
          self.ex.read(iprot)
12371 
        else:
12372 
          iprot.skip(ftype)
12373 
      else:
12374 
        iprot.skip(ftype)
12375 
      iprot.readFieldEnd()
12376 
    iprot.readStructEnd()
12377 
 
12378 
  def write(self, oprot):
12379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12381 
      return
3064 chandransh 12382 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12383 
    if self.success is not None:
3064 chandransh 12384 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12385 
      self.success.write(oprot)
94 ashish 12386 
      oprot.writeFieldEnd()
3431 rajveer 12387 
    if self.ex is not None:
94 ashish 12388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12389 
      self.ex.write(oprot)
12390 
      oprot.writeFieldEnd()
12391 
    oprot.writeFieldStop()
12392 
    oprot.writeStructEnd()
12393 
 
3431 rajveer 12394 
  def validate(self):
12395 
    return
12396 
 
12397 
 
94 ashish 12398 
  def __repr__(self):
12399 
    L = ['%s=%r' % (key, value)
12400 
      for key, value in self.__dict__.iteritems()]
12401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12402 
 
12403 
  def __eq__(self, other):
12404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12405 
 
12406 
  def __ne__(self, other):
12407 
    return not (self == other)
12408 
 
3064 chandransh 12409 
class getAlerts_args:
94 ashish 12410 
  """
12411 
  Attributes:
4394 rajveer 12412 
   - type
4444 rajveer 12413 
   - warehouseId
4394 rajveer 12414 
   - status
12415 
   - timestamp
94 ashish 12416 
  """
12417 
 
12418 
  thrift_spec = (
12419 
    None, # 0
4394 rajveer 12420 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12421 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12422 
    (3, TType.I64, 'status', None, None, ), # 3
12423 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12424 
  )
12425 
 
4444 rajveer 12426 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12427 
    self.type = type
4444 rajveer 12428 
    self.warehouseId = warehouseId
4394 rajveer 12429 
    self.status = status
12430 
    self.timestamp = timestamp
94 ashish 12431 
 
12432 
  def read(self, iprot):
12433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12435 
      return
12436 
    iprot.readStructBegin()
12437 
    while True:
12438 
      (fname, ftype, fid) = iprot.readFieldBegin()
12439 
      if ftype == TType.STOP:
12440 
        break
12441 
      if fid == 1:
3064 chandransh 12442 
        if ftype == TType.I64:
4394 rajveer 12443 
          self.type = iprot.readI64();
94 ashish 12444 
        else:
12445 
          iprot.skip(ftype)
3064 chandransh 12446 
      elif fid == 2:
4394 rajveer 12447 
        if ftype == TType.I64:
4444 rajveer 12448 
          self.warehouseId = iprot.readI64();
3064 chandransh 12449 
        else:
12450 
          iprot.skip(ftype)
4394 rajveer 12451 
      elif fid == 3:
12452 
        if ftype == TType.I64:
4444 rajveer 12453 
          self.status = iprot.readI64();
12454 
        else:
12455 
          iprot.skip(ftype)
12456 
      elif fid == 4:
12457 
        if ftype == TType.I64:
4394 rajveer 12458 
          self.timestamp = iprot.readI64();
12459 
        else:
12460 
          iprot.skip(ftype)
94 ashish 12461 
      else:
12462 
        iprot.skip(ftype)
12463 
      iprot.readFieldEnd()
12464 
    iprot.readStructEnd()
12465 
 
12466 
  def write(self, oprot):
12467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12469 
      return
3064 chandransh 12470 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12471 
    if self.type is not None:
12472 
      oprot.writeFieldBegin('type', TType.I64, 1)
12473 
      oprot.writeI64(self.type)
94 ashish 12474 
      oprot.writeFieldEnd()
4444 rajveer 12475 
    if self.warehouseId is not None:
12476 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12477 
      oprot.writeI64(self.warehouseId)
12478 
      oprot.writeFieldEnd()
4394 rajveer 12479 
    if self.status is not None:
4444 rajveer 12480 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12481 
      oprot.writeI64(self.status)
3064 chandransh 12482 
      oprot.writeFieldEnd()
4394 rajveer 12483 
    if self.timestamp is not None:
4444 rajveer 12484 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12485 
      oprot.writeI64(self.timestamp)
12486 
      oprot.writeFieldEnd()
94 ashish 12487 
    oprot.writeFieldStop()
12488 
    oprot.writeStructEnd()
12489 
 
3431 rajveer 12490 
  def validate(self):
12491 
    return
12492 
 
12493 
 
94 ashish 12494 
  def __repr__(self):
12495 
    L = ['%s=%r' % (key, value)
12496 
      for key, value in self.__dict__.iteritems()]
12497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12498 
 
12499 
  def __eq__(self, other):
12500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12501 
 
12502 
  def __ne__(self, other):
12503 
    return not (self == other)
12504 
 
3064 chandransh 12505 
class getAlerts_result:
94 ashish 12506 
  """
12507 
  Attributes:
12508 
   - success
12509 
  """
12510 
 
12511 
  thrift_spec = (
3064 chandransh 12512 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12513 
  )
12514 
 
3064 chandransh 12515 
  def __init__(self, success=None,):
94 ashish 12516 
    self.success = success
12517 
 
12518 
  def read(self, iprot):
12519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12521 
      return
12522 
    iprot.readStructBegin()
12523 
    while True:
12524 
      (fname, ftype, fid) = iprot.readFieldBegin()
12525 
      if ftype == TType.STOP:
12526 
        break
12527 
      if fid == 0:
3064 chandransh 12528 
        if ftype == TType.LIST:
12529 
          self.success = []
6188 rajveer 12530 
          (_etype242, _size239) = iprot.readListBegin()
12531 
          for _i243 in xrange(_size239):
12532 
            _elem244 = Alert()
12533 
            _elem244.read(iprot)
12534 
            self.success.append(_elem244)
3064 chandransh 12535 
          iprot.readListEnd()
94 ashish 12536 
        else:
12537 
          iprot.skip(ftype)
12538 
      else:
12539 
        iprot.skip(ftype)
12540 
      iprot.readFieldEnd()
12541 
    iprot.readStructEnd()
12542 
 
12543 
  def write(self, oprot):
12544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12546 
      return
3064 chandransh 12547 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12548 
    if self.success is not None:
3064 chandransh 12549 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12550 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12551 
      for iter245 in self.success:
12552 
        iter245.write(oprot)
3064 chandransh 12553 
      oprot.writeListEnd()
94 ashish 12554 
      oprot.writeFieldEnd()
12555 
    oprot.writeFieldStop()
12556 
    oprot.writeStructEnd()
12557 
 
3431 rajveer 12558 
  def validate(self):
12559 
    return
12560 
 
12561 
 
94 ashish 12562 
  def __repr__(self):
12563 
    L = ['%s=%r' % (key, value)
12564 
      for key, value in self.__dict__.iteritems()]
12565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12566 
 
12567 
  def __eq__(self, other):
12568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12569 
 
12570 
  def __ne__(self, other):
12571 
    return not (self == other)
12572 
 
4394 rajveer 12573 
class addAlert_args:
94 ashish 12574 
  """
12575 
  Attributes:
3064 chandransh 12576 
   - type
4444 rajveer 12577 
   - warehouseId
4394 rajveer 12578 
   - description
94 ashish 12579 
  """
12580 
 
12581 
  thrift_spec = (
12582 
    None, # 0
4394 rajveer 12583 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12584 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12585 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12586 
  )
12587 
 
4444 rajveer 12588 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12589 
    self.type = type
4444 rajveer 12590 
    self.warehouseId = warehouseId
4394 rajveer 12591 
    self.description = description
94 ashish 12592 
 
12593 
  def read(self, iprot):
12594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12596 
      return
12597 
    iprot.readStructBegin()
12598 
    while True:
12599 
      (fname, ftype, fid) = iprot.readFieldBegin()
12600 
      if ftype == TType.STOP:
12601 
        break
12602 
      if fid == 1:
12603 
        if ftype == TType.I64:
4394 rajveer 12604 
          self.type = iprot.readI64();
94 ashish 12605 
        else:
12606 
          iprot.skip(ftype)
3064 chandransh 12607 
      elif fid == 2:
4444 rajveer 12608 
        if ftype == TType.I64:
12609 
          self.warehouseId = iprot.readI64();
12610 
        else:
12611 
          iprot.skip(ftype)
12612 
      elif fid == 3:
3064 chandransh 12613 
        if ftype == TType.STRING:
4394 rajveer 12614 
          self.description = iprot.readString();
3064 chandransh 12615 
        else:
12616 
          iprot.skip(ftype)
94 ashish 12617 
      else:
12618 
        iprot.skip(ftype)
12619 
      iprot.readFieldEnd()
12620 
    iprot.readStructEnd()
12621 
 
12622 
  def write(self, oprot):
12623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12625 
      return
4394 rajveer 12626 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12627 
    if self.type is not None:
4394 rajveer 12628 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12629 
      oprot.writeI64(self.type)
12630 
      oprot.writeFieldEnd()
4444 rajveer 12631 
    if self.warehouseId is not None:
12632 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12633 
      oprot.writeI64(self.warehouseId)
12634 
      oprot.writeFieldEnd()
4394 rajveer 12635 
    if self.description is not None:
4444 rajveer 12636 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12637 
      oprot.writeString(self.description)
3064 chandransh 12638 
      oprot.writeFieldEnd()
94 ashish 12639 
    oprot.writeFieldStop()
12640 
    oprot.writeStructEnd()
12641 
 
3431 rajveer 12642 
  def validate(self):
12643 
    return
12644 
 
12645 
 
94 ashish 12646 
  def __repr__(self):
12647 
    L = ['%s=%r' % (key, value)
12648 
      for key, value in self.__dict__.iteritems()]
12649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12650 
 
12651 
  def __eq__(self, other):
12652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12653 
 
12654 
  def __ne__(self, other):
12655 
    return not (self == other)
12656 
 
4394 rajveer 12657 
class addAlert_result:
3064 chandransh 12658 
 
12659 
  thrift_spec = (
12660 
  )
12661 
 
12662 
  def read(self, iprot):
12663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12665 
      return
12666 
    iprot.readStructBegin()
12667 
    while True:
12668 
      (fname, ftype, fid) = iprot.readFieldBegin()
12669 
      if ftype == TType.STOP:
12670 
        break
12671 
      else:
12672 
        iprot.skip(ftype)
12673 
      iprot.readFieldEnd()
12674 
    iprot.readStructEnd()
12675 
 
12676 
  def write(self, oprot):
12677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12679 
      return
4394 rajveer 12680 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12681 
    oprot.writeFieldStop()
12682 
    oprot.writeStructEnd()
12683 
 
3431 rajveer 12684 
  def validate(self):
12685 
    return
12686 
 
12687 
 
3064 chandransh 12688 
  def __repr__(self):
12689 
    L = ['%s=%r' % (key, value)
12690 
      for key, value in self.__dict__.iteritems()]
12691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12692 
 
12693 
  def __eq__(self, other):
12694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12695 
 
12696 
  def __ne__(self, other):
12697 
    return not (self == other)
12698 
 
4444 rajveer 12699 
class markAlertsAsSeen_args:
12700 
  """
12701 
  Attributes:
12702 
   - warehouseId
12703 
  """
12704 
 
12705 
  thrift_spec = (
12706 
    None, # 0
12707 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12708 
  )
12709 
 
12710 
  def __init__(self, warehouseId=None,):
12711 
    self.warehouseId = warehouseId
12712 
 
12713 
  def read(self, iprot):
12714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12716 
      return
12717 
    iprot.readStructBegin()
12718 
    while True:
12719 
      (fname, ftype, fid) = iprot.readFieldBegin()
12720 
      if ftype == TType.STOP:
12721 
        break
12722 
      if fid == 1:
12723 
        if ftype == TType.I64:
12724 
          self.warehouseId = iprot.readI64();
12725 
        else:
12726 
          iprot.skip(ftype)
12727 
      else:
12728 
        iprot.skip(ftype)
12729 
      iprot.readFieldEnd()
12730 
    iprot.readStructEnd()
12731 
 
12732 
  def write(self, oprot):
12733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12735 
      return
12736 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12737 
    if self.warehouseId is not None:
12738 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12739 
      oprot.writeI64(self.warehouseId)
12740 
      oprot.writeFieldEnd()
12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
12744 
  def validate(self):
12745 
    return
12746 
 
12747 
 
12748 
  def __repr__(self):
12749 
    L = ['%s=%r' % (key, value)
12750 
      for key, value in self.__dict__.iteritems()]
12751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12752 
 
12753 
  def __eq__(self, other):
12754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12755 
 
12756 
  def __ne__(self, other):
12757 
    return not (self == other)
12758 
 
12759 
class markAlertsAsSeen_result:
12760 
 
12761 
  thrift_spec = (
12762 
  )
12763 
 
12764 
  def read(self, iprot):
12765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12767 
      return
12768 
    iprot.readStructBegin()
12769 
    while True:
12770 
      (fname, ftype, fid) = iprot.readFieldBegin()
12771 
      if ftype == TType.STOP:
12772 
        break
12773 
      else:
12774 
        iprot.skip(ftype)
12775 
      iprot.readFieldEnd()
12776 
    iprot.readStructEnd()
12777 
 
12778 
  def write(self, oprot):
12779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12781 
      return
12782 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12783 
    oprot.writeFieldStop()
12784 
    oprot.writeStructEnd()
12785 
 
12786 
  def validate(self):
12787 
    return
12788 
 
12789 
 
12790 
  def __repr__(self):
12791 
    L = ['%s=%r' % (key, value)
12792 
      for key, value in self.__dict__.iteritems()]
12793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12794 
 
12795 
  def __eq__(self, other):
12796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12797 
 
12798 
  def __ne__(self, other):
12799 
    return not (self == other)
12800 
 
3064 chandransh 12801 
class getValidOrderCount_args:
12802 
 
12803 
  thrift_spec = (
12804 
  )
12805 
 
12806 
  def read(self, iprot):
12807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12809 
      return
12810 
    iprot.readStructBegin()
12811 
    while True:
12812 
      (fname, ftype, fid) = iprot.readFieldBegin()
12813 
      if ftype == TType.STOP:
12814 
        break
12815 
      else:
12816 
        iprot.skip(ftype)
12817 
      iprot.readFieldEnd()
12818 
    iprot.readStructEnd()
12819 
 
12820 
  def write(self, oprot):
12821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12823 
      return
12824 
    oprot.writeStructBegin('getValidOrderCount_args')
12825 
    oprot.writeFieldStop()
12826 
    oprot.writeStructEnd()
12827 
 
3431 rajveer 12828 
  def validate(self):
12829 
    return
12830 
 
12831 
 
3064 chandransh 12832 
  def __repr__(self):
12833 
    L = ['%s=%r' % (key, value)
12834 
      for key, value in self.__dict__.iteritems()]
12835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12836 
 
12837 
  def __eq__(self, other):
12838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12839 
 
12840 
  def __ne__(self, other):
12841 
    return not (self == other)
12842 
 
12843 
class getValidOrderCount_result:
94 ashish 12844 
  """
12845 
  Attributes:
12846 
   - success
12847 
  """
12848 
 
12849 
  thrift_spec = (
3064 chandransh 12850 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12851 
  )
12852 
 
3064 chandransh 12853 
  def __init__(self, success=None,):
94 ashish 12854 
    self.success = success
12855 
 
12856 
  def read(self, iprot):
12857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12859 
      return
12860 
    iprot.readStructBegin()
12861 
    while True:
12862 
      (fname, ftype, fid) = iprot.readFieldBegin()
12863 
      if ftype == TType.STOP:
12864 
        break
12865 
      if fid == 0:
3064 chandransh 12866 
        if ftype == TType.I64:
12867 
          self.success = iprot.readI64();
94 ashish 12868 
        else:
12869 
          iprot.skip(ftype)
12870 
      else:
12871 
        iprot.skip(ftype)
12872 
      iprot.readFieldEnd()
12873 
    iprot.readStructEnd()
12874 
 
12875 
  def write(self, oprot):
12876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12878 
      return
3064 chandransh 12879 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12880 
    if self.success is not None:
3064 chandransh 12881 
      oprot.writeFieldBegin('success', TType.I64, 0)
12882 
      oprot.writeI64(self.success)
94 ashish 12883 
      oprot.writeFieldEnd()
12884 
    oprot.writeFieldStop()
12885 
    oprot.writeStructEnd()
12886 
 
3431 rajveer 12887 
  def validate(self):
12888 
    return
12889 
 
12890 
 
94 ashish 12891 
  def __repr__(self):
12892 
    L = ['%s=%r' % (key, value)
12893 
      for key, value in self.__dict__.iteritems()]
12894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12895 
 
12896 
  def __eq__(self, other):
12897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12898 
 
12899 
  def __ne__(self, other):
12900 
    return not (self == other)
12901 
 
3064 chandransh 12902 
class getNoOfCustomersWithSuccessfulTransaction_args:
12903 
 
12904 
  thrift_spec = (
12905 
  )
12906 
 
12907 
  def read(self, iprot):
12908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12910 
      return
12911 
    iprot.readStructBegin()
12912 
    while True:
12913 
      (fname, ftype, fid) = iprot.readFieldBegin()
12914 
      if ftype == TType.STOP:
12915 
        break
12916 
      else:
12917 
        iprot.skip(ftype)
12918 
      iprot.readFieldEnd()
12919 
    iprot.readStructEnd()
12920 
 
12921 
  def write(self, oprot):
12922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12924 
      return
12925 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12926 
    oprot.writeFieldStop()
12927 
    oprot.writeStructEnd()
12928 
 
3431 rajveer 12929 
  def validate(self):
12930 
    return
12931 
 
12932 
 
3064 chandransh 12933 
  def __repr__(self):
12934 
    L = ['%s=%r' % (key, value)
12935 
      for key, value in self.__dict__.iteritems()]
12936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12937 
 
12938 
  def __eq__(self, other):
12939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12940 
 
12941 
  def __ne__(self, other):
12942 
    return not (self == other)
12943 
 
12944 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12945 
  """
12946 
  Attributes:
3064 chandransh 12947 
   - success
94 ashish 12948 
  """
12949 
 
12950 
  thrift_spec = (
3064 chandransh 12951 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12952 
  )
12953 
 
3064 chandransh 12954 
  def __init__(self, success=None,):
12955 
    self.success = success
94 ashish 12956 
 
12957 
  def read(self, iprot):
12958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12960 
      return
12961 
    iprot.readStructBegin()
12962 
    while True:
12963 
      (fname, ftype, fid) = iprot.readFieldBegin()
12964 
      if ftype == TType.STOP:
12965 
        break
3064 chandransh 12966 
      if fid == 0:
94 ashish 12967 
        if ftype == TType.I64:
3064 chandransh 12968 
          self.success = iprot.readI64();
94 ashish 12969 
        else:
12970 
          iprot.skip(ftype)
12971 
      else:
12972 
        iprot.skip(ftype)
12973 
      iprot.readFieldEnd()
12974 
    iprot.readStructEnd()
12975 
 
12976 
  def write(self, oprot):
12977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12979 
      return
3064 chandransh 12980 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12981 
    if self.success is not None:
3064 chandransh 12982 
      oprot.writeFieldBegin('success', TType.I64, 0)
12983 
      oprot.writeI64(self.success)
94 ashish 12984 
      oprot.writeFieldEnd()
12985 
    oprot.writeFieldStop()
12986 
    oprot.writeStructEnd()
12987 
 
3431 rajveer 12988 
  def validate(self):
12989 
    return
12990 
 
12991 
 
94 ashish 12992 
  def __repr__(self):
12993 
    L = ['%s=%r' % (key, value)
12994 
      for key, value in self.__dict__.iteritems()]
12995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12996 
 
12997 
  def __eq__(self, other):
12998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12999 
 
13000 
  def __ne__(self, other):
13001 
    return not (self == other)
13002 
 
3064 chandransh 13003 
class getValidOrdersAmountRange_args:
13004 
 
13005 
  thrift_spec = (
13006 
  )
13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      else:
13018 
        iprot.skip(ftype)
13019 
      iprot.readFieldEnd()
13020 
    iprot.readStructEnd()
13021 
 
13022 
  def write(self, oprot):
13023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13025 
      return
13026 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13027 
    oprot.writeFieldStop()
13028 
    oprot.writeStructEnd()
13029 
 
3431 rajveer 13030 
  def validate(self):
13031 
    return
13032 
 
13033 
 
3064 chandransh 13034 
  def __repr__(self):
13035 
    L = ['%s=%r' % (key, value)
13036 
      for key, value in self.__dict__.iteritems()]
13037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13038 
 
13039 
  def __eq__(self, other):
13040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13041 
 
13042 
  def __ne__(self, other):
13043 
    return not (self == other)
13044 
 
13045 
class getValidOrdersAmountRange_result:
94 ashish 13046 
  """
13047 
  Attributes:
13048 
   - success
13049 
  """
13050 
 
13051 
  thrift_spec = (
3064 chandransh 13052 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13053 
  )
13054 
 
3064 chandransh 13055 
  def __init__(self, success=None,):
94 ashish 13056 
    self.success = success
13057 
 
13058 
  def read(self, iprot):
13059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13061 
      return
13062 
    iprot.readStructBegin()
13063 
    while True:
13064 
      (fname, ftype, fid) = iprot.readFieldBegin()
13065 
      if ftype == TType.STOP:
13066 
        break
13067 
      if fid == 0:
483 rajveer 13068 
        if ftype == TType.LIST:
13069 
          self.success = []
6188 rajveer 13070 
          (_etype249, _size246) = iprot.readListBegin()
13071 
          for _i250 in xrange(_size246):
13072 
            _elem251 = iprot.readDouble();
13073 
            self.success.append(_elem251)
483 rajveer 13074 
          iprot.readListEnd()
94 ashish 13075 
        else:
13076 
          iprot.skip(ftype)
13077 
      else:
13078 
        iprot.skip(ftype)
13079 
      iprot.readFieldEnd()
13080 
    iprot.readStructEnd()
13081 
 
13082 
  def write(self, oprot):
13083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13085 
      return
3064 chandransh 13086 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13087 
    if self.success is not None:
483 rajveer 13088 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13089 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13090 
      for iter252 in self.success:
13091 
        oprot.writeDouble(iter252)
483 rajveer 13092 
      oprot.writeListEnd()
94 ashish 13093 
      oprot.writeFieldEnd()
13094 
    oprot.writeFieldStop()
13095 
    oprot.writeStructEnd()
13096 
 
3431 rajveer 13097 
  def validate(self):
13098 
    return
13099 
 
13100 
 
94 ashish 13101 
  def __repr__(self):
13102 
    L = ['%s=%r' % (key, value)
13103 
      for key, value in self.__dict__.iteritems()]
13104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13105 
 
13106 
  def __eq__(self, other):
13107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13108 
 
13109 
  def __ne__(self, other):
13110 
    return not (self == other)
13111 
 
3064 chandransh 13112 
class getValidOrders_args:
1528 ankur.sing 13113 
  """
13114 
  Attributes:
3064 chandransh 13115 
   - limit
5874 rajveer 13116 
   - onlyStore
1528 ankur.sing 13117 
  """
13118 
 
13119 
  thrift_spec = (
13120 
    None, # 0
3064 chandransh 13121 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13122 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13123 
  )
13124 
 
5874 rajveer 13125 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13126 
    self.limit = limit
5874 rajveer 13127 
    self.onlyStore = onlyStore
1528 ankur.sing 13128 
 
13129 
  def read(self, iprot):
13130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13132 
      return
13133 
    iprot.readStructBegin()
13134 
    while True:
13135 
      (fname, ftype, fid) = iprot.readFieldBegin()
13136 
      if ftype == TType.STOP:
13137 
        break
13138 
      if fid == 1:
13139 
        if ftype == TType.I64:
3064 chandransh 13140 
          self.limit = iprot.readI64();
1528 ankur.sing 13141 
        else:
13142 
          iprot.skip(ftype)
5874 rajveer 13143 
      elif fid == 2:
13144 
        if ftype == TType.BOOL:
13145 
          self.onlyStore = iprot.readBool();
13146 
        else:
13147 
          iprot.skip(ftype)
1528 ankur.sing 13148 
      else:
13149 
        iprot.skip(ftype)
13150 
      iprot.readFieldEnd()
13151 
    iprot.readStructEnd()
13152 
 
13153 
  def write(self, oprot):
13154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13156 
      return
3064 chandransh 13157 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13158 
    if self.limit is not None:
3064 chandransh 13159 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13160 
      oprot.writeI64(self.limit)
1528 ankur.sing 13161 
      oprot.writeFieldEnd()
5874 rajveer 13162 
    if self.onlyStore is not None:
13163 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13164 
      oprot.writeBool(self.onlyStore)
13165 
      oprot.writeFieldEnd()
1528 ankur.sing 13166 
    oprot.writeFieldStop()
13167 
    oprot.writeStructEnd()
13168 
 
3431 rajveer 13169 
  def validate(self):
13170 
    return
13171 
 
13172 
 
1528 ankur.sing 13173 
  def __repr__(self):
13174 
    L = ['%s=%r' % (key, value)
13175 
      for key, value in self.__dict__.iteritems()]
13176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13177 
 
13178 
  def __eq__(self, other):
13179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13180 
 
13181 
  def __ne__(self, other):
13182 
    return not (self == other)
13183 
 
3064 chandransh 13184 
class getValidOrders_result:
1528 ankur.sing 13185 
  """
13186 
  Attributes:
13187 
   - success
13188 
  """
13189 
 
13190 
  thrift_spec = (
3064 chandransh 13191 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13192 
  )
13193 
 
3064 chandransh 13194 
  def __init__(self, success=None,):
1528 ankur.sing 13195 
    self.success = success
13196 
 
13197 
  def read(self, iprot):
13198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13200 
      return
13201 
    iprot.readStructBegin()
13202 
    while True:
13203 
      (fname, ftype, fid) = iprot.readFieldBegin()
13204 
      if ftype == TType.STOP:
13205 
        break
13206 
      if fid == 0:
3064 chandransh 13207 
        if ftype == TType.LIST:
13208 
          self.success = []
6188 rajveer 13209 
          (_etype256, _size253) = iprot.readListBegin()
13210 
          for _i257 in xrange(_size253):
13211 
            _elem258 = Order()
13212 
            _elem258.read(iprot)
13213 
            self.success.append(_elem258)
3064 chandransh 13214 
          iprot.readListEnd()
1528 ankur.sing 13215 
        else:
13216 
          iprot.skip(ftype)
13217 
      else:
13218 
        iprot.skip(ftype)
13219 
      iprot.readFieldEnd()
13220 
    iprot.readStructEnd()
13221 
 
13222 
  def write(self, oprot):
13223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13225 
      return
3064 chandransh 13226 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13227 
    if self.success is not None:
3064 chandransh 13228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13229 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13230 
      for iter259 in self.success:
13231 
        iter259.write(oprot)
3064 chandransh 13232 
      oprot.writeListEnd()
1528 ankur.sing 13233 
      oprot.writeFieldEnd()
13234 
    oprot.writeFieldStop()
13235 
    oprot.writeStructEnd()
13236 
 
3431 rajveer 13237 
  def validate(self):
13238 
    return
13239 
 
13240 
 
1528 ankur.sing 13241 
  def __repr__(self):
13242 
    L = ['%s=%r' % (key, value)
13243 
      for key, value in self.__dict__.iteritems()]
13244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13245 
 
13246 
  def __eq__(self, other):
13247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13248 
 
13249 
  def __ne__(self, other):
13250 
    return not (self == other)
13251 
 
1220 chandransh 13252 
class batchOrders_args:
13253 
  """
13254 
  Attributes:
13255 
   - warehouseId
13256 
  """
13257 
 
13258 
  thrift_spec = (
13259 
    None, # 0
13260 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13261 
  )
13262 
 
13263 
  def __init__(self, warehouseId=None,):
13264 
    self.warehouseId = warehouseId
13265 
 
13266 
  def read(self, iprot):
13267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13269 
      return
13270 
    iprot.readStructBegin()
13271 
    while True:
13272 
      (fname, ftype, fid) = iprot.readFieldBegin()
13273 
      if ftype == TType.STOP:
13274 
        break
13275 
      if fid == 1:
13276 
        if ftype == TType.I64:
13277 
          self.warehouseId = iprot.readI64();
13278 
        else:
13279 
          iprot.skip(ftype)
13280 
      else:
13281 
        iprot.skip(ftype)
13282 
      iprot.readFieldEnd()
13283 
    iprot.readStructEnd()
13284 
 
13285 
  def write(self, oprot):
13286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13288 
      return
13289 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13290 
    if self.warehouseId is not None:
1220 chandransh 13291 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13292 
      oprot.writeI64(self.warehouseId)
13293 
      oprot.writeFieldEnd()
13294 
    oprot.writeFieldStop()
13295 
    oprot.writeStructEnd()
13296 
 
3431 rajveer 13297 
  def validate(self):
13298 
    return
13299 
 
13300 
 
1220 chandransh 13301 
  def __repr__(self):
13302 
    L = ['%s=%r' % (key, value)
13303 
      for key, value in self.__dict__.iteritems()]
13304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13305 
 
13306 
  def __eq__(self, other):
13307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13308 
 
13309 
  def __ne__(self, other):
13310 
    return not (self == other)
13311 
 
13312 
class batchOrders_result:
13313 
  """
13314 
  Attributes:
13315 
   - success
13316 
   - ex
13317 
  """
13318 
 
13319 
  thrift_spec = (
13320 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13321 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13322 
  )
13323 
 
13324 
  def __init__(self, success=None, ex=None,):
13325 
    self.success = success
13326 
    self.ex = ex
13327 
 
13328 
  def read(self, iprot):
13329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13331 
      return
13332 
    iprot.readStructBegin()
13333 
    while True:
13334 
      (fname, ftype, fid) = iprot.readFieldBegin()
13335 
      if ftype == TType.STOP:
13336 
        break
13337 
      if fid == 0:
13338 
        if ftype == TType.LIST:
13339 
          self.success = []
6188 rajveer 13340 
          (_etype263, _size260) = iprot.readListBegin()
13341 
          for _i264 in xrange(_size260):
13342 
            _elem265 = Order()
13343 
            _elem265.read(iprot)
13344 
            self.success.append(_elem265)
1220 chandransh 13345 
          iprot.readListEnd()
13346 
        else:
13347 
          iprot.skip(ftype)
13348 
      elif fid == 1:
13349 
        if ftype == TType.STRUCT:
13350 
          self.ex = TransactionServiceException()
13351 
          self.ex.read(iprot)
13352 
        else:
13353 
          iprot.skip(ftype)
13354 
      else:
13355 
        iprot.skip(ftype)
13356 
      iprot.readFieldEnd()
13357 
    iprot.readStructEnd()
13358 
 
13359 
  def write(self, oprot):
13360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13362 
      return
13363 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13364 
    if self.success is not None:
1220 chandransh 13365 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13366 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13367 
      for iter266 in self.success:
13368 
        iter266.write(oprot)
1220 chandransh 13369 
      oprot.writeListEnd()
13370 
      oprot.writeFieldEnd()
3431 rajveer 13371 
    if self.ex is not None:
1220 chandransh 13372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13373 
      self.ex.write(oprot)
13374 
      oprot.writeFieldEnd()
13375 
    oprot.writeFieldStop()
13376 
    oprot.writeStructEnd()
13377 
 
3431 rajveer 13378 
  def validate(self):
13379 
    return
13380 
 
13381 
 
1220 chandransh 13382 
  def __repr__(self):
13383 
    L = ['%s=%r' % (key, value)
13384 
      for key, value in self.__dict__.iteritems()]
13385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13386 
 
13387 
  def __eq__(self, other):
13388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13389 
 
13390 
  def __ne__(self, other):
13391 
    return not (self == other)
13392 
 
1208 chandransh 13393 
class markOrderAsOutOfStock_args:
13394 
  """
13395 
  Attributes:
13396 
   - orderId
13397 
  """
13398 
 
13399 
  thrift_spec = (
13400 
    None, # 0
13401 
    (1, TType.I64, 'orderId', None, None, ), # 1
13402 
  )
13403 
 
13404 
  def __init__(self, orderId=None,):
13405 
    self.orderId = orderId
13406 
 
13407 
  def read(self, iprot):
13408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13410 
      return
13411 
    iprot.readStructBegin()
13412 
    while True:
13413 
      (fname, ftype, fid) = iprot.readFieldBegin()
13414 
      if ftype == TType.STOP:
13415 
        break
13416 
      if fid == 1:
13417 
        if ftype == TType.I64:
13418 
          self.orderId = iprot.readI64();
13419 
        else:
13420 
          iprot.skip(ftype)
13421 
      else:
13422 
        iprot.skip(ftype)
13423 
      iprot.readFieldEnd()
13424 
    iprot.readStructEnd()
13425 
 
13426 
  def write(self, oprot):
13427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13429 
      return
13430 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13431 
    if self.orderId is not None:
1208 chandransh 13432 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13433 
      oprot.writeI64(self.orderId)
13434 
      oprot.writeFieldEnd()
13435 
    oprot.writeFieldStop()
13436 
    oprot.writeStructEnd()
13437 
 
3431 rajveer 13438 
  def validate(self):
13439 
    return
13440 
 
13441 
 
1208 chandransh 13442 
  def __repr__(self):
13443 
    L = ['%s=%r' % (key, value)
13444 
      for key, value in self.__dict__.iteritems()]
13445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13446 
 
13447 
  def __eq__(self, other):
13448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13449 
 
13450 
  def __ne__(self, other):
13451 
    return not (self == other)
13452 
 
13453 
class markOrderAsOutOfStock_result:
13454 
  """
13455 
  Attributes:
13456 
   - success
13457 
   - ex
13458 
  """
13459 
 
13460 
  thrift_spec = (
13461 
    (0, TType.BOOL, 'success', None, None, ), # 0
13462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13463 
  )
13464 
 
13465 
  def __init__(self, success=None, ex=None,):
13466 
    self.success = success
13467 
    self.ex = ex
13468 
 
13469 
  def read(self, iprot):
13470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13472 
      return
13473 
    iprot.readStructBegin()
13474 
    while True:
13475 
      (fname, ftype, fid) = iprot.readFieldBegin()
13476 
      if ftype == TType.STOP:
13477 
        break
13478 
      if fid == 0:
13479 
        if ftype == TType.BOOL:
13480 
          self.success = iprot.readBool();
13481 
        else:
13482 
          iprot.skip(ftype)
13483 
      elif fid == 1:
13484 
        if ftype == TType.STRUCT:
13485 
          self.ex = TransactionServiceException()
13486 
          self.ex.read(iprot)
13487 
        else:
13488 
          iprot.skip(ftype)
13489 
      else:
13490 
        iprot.skip(ftype)
13491 
      iprot.readFieldEnd()
13492 
    iprot.readStructEnd()
13493 
 
13494 
  def write(self, oprot):
13495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13497 
      return
13498 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13499 
    if self.success is not None:
1208 chandransh 13500 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13501 
      oprot.writeBool(self.success)
13502 
      oprot.writeFieldEnd()
3431 rajveer 13503 
    if self.ex is not None:
1208 chandransh 13504 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13505 
      self.ex.write(oprot)
13506 
      oprot.writeFieldEnd()
13507 
    oprot.writeFieldStop()
13508 
    oprot.writeStructEnd()
13509 
 
3431 rajveer 13510 
  def validate(self):
13511 
    return
13512 
 
13513 
 
1208 chandransh 13514 
  def __repr__(self):
13515 
    L = ['%s=%r' % (key, value)
13516 
      for key, value in self.__dict__.iteritems()]
13517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13518 
 
13519 
  def __eq__(self, other):
13520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13521 
 
13522 
  def __ne__(self, other):
13523 
    return not (self == other)
13524 
 
3064 chandransh 13525 
class verifyOrder_args:
759 chandransh 13526 
  """
13527 
  Attributes:
3064 chandransh 13528 
   - orderId
759 chandransh 13529 
  """
13530 
 
13531 
  thrift_spec = (
13532 
    None, # 0
3064 chandransh 13533 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13534 
  )
13535 
 
3064 chandransh 13536 
  def __init__(self, orderId=None,):
13537 
    self.orderId = orderId
759 chandransh 13538 
 
13539 
  def read(self, iprot):
13540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13542 
      return
13543 
    iprot.readStructBegin()
13544 
    while True:
13545 
      (fname, ftype, fid) = iprot.readFieldBegin()
13546 
      if ftype == TType.STOP:
13547 
        break
13548 
      if fid == 1:
13549 
        if ftype == TType.I64:
3064 chandransh 13550 
          self.orderId = iprot.readI64();
759 chandransh 13551 
        else:
13552 
          iprot.skip(ftype)
13553 
      else:
13554 
        iprot.skip(ftype)
13555 
      iprot.readFieldEnd()
13556 
    iprot.readStructEnd()
13557 
 
13558 
  def write(self, oprot):
13559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13561 
      return
3064 chandransh 13562 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13563 
    if self.orderId is not None:
3064 chandransh 13564 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13565 
      oprot.writeI64(self.orderId)
759 chandransh 13566 
      oprot.writeFieldEnd()
13567 
    oprot.writeFieldStop()
13568 
    oprot.writeStructEnd()
13569 
 
3431 rajveer 13570 
  def validate(self):
13571 
    return
13572 
 
13573 
 
759 chandransh 13574 
  def __repr__(self):
13575 
    L = ['%s=%r' % (key, value)
13576 
      for key, value in self.__dict__.iteritems()]
13577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13578 
 
13579 
  def __eq__(self, other):
13580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13581 
 
13582 
  def __ne__(self, other):
13583 
    return not (self == other)
13584 
 
3064 chandransh 13585 
class verifyOrder_result:
759 chandransh 13586 
  """
13587 
  Attributes:
13588 
   - success
13589 
   - ex
13590 
  """
13591 
 
13592 
  thrift_spec = (
13593 
    (0, TType.BOOL, 'success', None, None, ), # 0
13594 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13595 
  )
13596 
 
13597 
  def __init__(self, success=None, ex=None,):
13598 
    self.success = success
13599 
    self.ex = ex
13600 
 
13601 
  def read(self, iprot):
13602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13604 
      return
13605 
    iprot.readStructBegin()
13606 
    while True:
13607 
      (fname, ftype, fid) = iprot.readFieldBegin()
13608 
      if ftype == TType.STOP:
13609 
        break
13610 
      if fid == 0:
13611 
        if ftype == TType.BOOL:
13612 
          self.success = iprot.readBool();
13613 
        else:
13614 
          iprot.skip(ftype)
13615 
      elif fid == 1:
13616 
        if ftype == TType.STRUCT:
13617 
          self.ex = TransactionServiceException()
13618 
          self.ex.read(iprot)
13619 
        else:
13620 
          iprot.skip(ftype)
13621 
      else:
13622 
        iprot.skip(ftype)
13623 
      iprot.readFieldEnd()
13624 
    iprot.readStructEnd()
13625 
 
13626 
  def write(self, oprot):
13627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13629 
      return
3064 chandransh 13630 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13631 
    if self.success is not None:
759 chandransh 13632 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13633 
      oprot.writeBool(self.success)
13634 
      oprot.writeFieldEnd()
3431 rajveer 13635 
    if self.ex is not None:
759 chandransh 13636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13637 
      self.ex.write(oprot)
13638 
      oprot.writeFieldEnd()
13639 
    oprot.writeFieldStop()
13640 
    oprot.writeStructEnd()
13641 
 
3431 rajveer 13642 
  def validate(self):
13643 
    return
13644 
 
13645 
 
759 chandransh 13646 
  def __repr__(self):
13647 
    L = ['%s=%r' % (key, value)
13648 
      for key, value in self.__dict__.iteritems()]
13649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13650 
 
13651 
  def __eq__(self, other):
13652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13653 
 
13654 
  def __ne__(self, other):
13655 
    return not (self == other)
13656 
 
3064 chandransh 13657 
class acceptOrder_args:
1113 chandransh 13658 
  """
13659 
  Attributes:
3064 chandransh 13660 
   - orderId
1113 chandransh 13661 
  """
13662 
 
13663 
  thrift_spec = (
13664 
    None, # 0
3064 chandransh 13665 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13666 
  )
13667 
 
3064 chandransh 13668 
  def __init__(self, orderId=None,):
13669 
    self.orderId = orderId
1113 chandransh 13670 
 
13671 
  def read(self, iprot):
13672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13674 
      return
13675 
    iprot.readStructBegin()
13676 
    while True:
13677 
      (fname, ftype, fid) = iprot.readFieldBegin()
13678 
      if ftype == TType.STOP:
13679 
        break
13680 
      if fid == 1:
13681 
        if ftype == TType.I64:
3064 chandransh 13682 
          self.orderId = iprot.readI64();
1113 chandransh 13683 
        else:
13684 
          iprot.skip(ftype)
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
3064 chandransh 13694 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13695 
    if self.orderId is not None:
3064 chandransh 13696 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13697 
      oprot.writeI64(self.orderId)
1113 chandransh 13698 
      oprot.writeFieldEnd()
13699 
    oprot.writeFieldStop()
13700 
    oprot.writeStructEnd()
13701 
 
3431 rajveer 13702 
  def validate(self):
13703 
    return
13704 
 
13705 
 
1113 chandransh 13706 
  def __repr__(self):
13707 
    L = ['%s=%r' % (key, value)
13708 
      for key, value in self.__dict__.iteritems()]
13709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13710 
 
13711 
  def __eq__(self, other):
13712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13713 
 
13714 
  def __ne__(self, other):
13715 
    return not (self == other)
13716 
 
3064 chandransh 13717 
class acceptOrder_result:
1113 chandransh 13718 
  """
13719 
  Attributes:
13720 
   - success
13721 
   - ex
13722 
  """
13723 
 
13724 
  thrift_spec = (
3064 chandransh 13725 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13727 
  )
13728 
 
13729 
  def __init__(self, success=None, ex=None,):
13730 
    self.success = success
13731 
    self.ex = ex
13732 
 
13733 
  def read(self, iprot):
13734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13736 
      return
13737 
    iprot.readStructBegin()
13738 
    while True:
13739 
      (fname, ftype, fid) = iprot.readFieldBegin()
13740 
      if ftype == TType.STOP:
13741 
        break
13742 
      if fid == 0:
3064 chandransh 13743 
        if ftype == TType.BOOL:
13744 
          self.success = iprot.readBool();
1113 chandransh 13745 
        else:
13746 
          iprot.skip(ftype)
13747 
      elif fid == 1:
13748 
        if ftype == TType.STRUCT:
13749 
          self.ex = TransactionServiceException()
13750 
          self.ex.read(iprot)
13751 
        else:
13752 
          iprot.skip(ftype)
13753 
      else:
13754 
        iprot.skip(ftype)
13755 
      iprot.readFieldEnd()
13756 
    iprot.readStructEnd()
13757 
 
13758 
  def write(self, oprot):
13759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13761 
      return
3064 chandransh 13762 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13763 
    if self.success is not None:
3064 chandransh 13764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13765 
      oprot.writeBool(self.success)
1113 chandransh 13766 
      oprot.writeFieldEnd()
3431 rajveer 13767 
    if self.ex is not None:
1113 chandransh 13768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13769 
      self.ex.write(oprot)
13770 
      oprot.writeFieldEnd()
13771 
    oprot.writeFieldStop()
13772 
    oprot.writeStructEnd()
13773 
 
3431 rajveer 13774 
  def validate(self):
13775 
    return
13776 
 
13777 
 
1113 chandransh 13778 
  def __repr__(self):
13779 
    L = ['%s=%r' % (key, value)
13780 
      for key, value in self.__dict__.iteritems()]
13781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13782 
 
13783 
  def __eq__(self, other):
13784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13785 
 
13786 
  def __ne__(self, other):
13787 
    return not (self == other)
13788 
 
3064 chandransh 13789 
class addBillingDetails_args:
1135 chandransh 13790 
  """
13791 
  Attributes:
3064 chandransh 13792 
   - orderId
13793 
   - invoice_number
4658 mandeep.dh 13794 
   - serialNumber
4283 anupam.sin 13795 
   - itemNumber
3064 chandransh 13796 
   - billed_by
4264 rajveer 13797 
   - jacketNumber
4283 anupam.sin 13798 
   - billingType
5110 mandeep.dh 13799 
   - fulfilmentWarehouseId
4763 rajveer 13800 
   - authorize
1135 chandransh 13801 
  """
13802 
 
13803 
  thrift_spec = (
13804 
    None, # 0
3064 chandransh 13805 
    (1, TType.I64, 'orderId', None, None, ), # 1
13806 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13807 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13808 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13809 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13810 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13811 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13812 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13813 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13814 
  )
13815 
 
5110 mandeep.dh 13816 
  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 13817 
    self.orderId = orderId
13818 
    self.invoice_number = invoice_number
4658 mandeep.dh 13819 
    self.serialNumber = serialNumber
4283 anupam.sin 13820 
    self.itemNumber = itemNumber
3064 chandransh 13821 
    self.billed_by = billed_by
4264 rajveer 13822 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13823 
    self.billingType = billingType
5110 mandeep.dh 13824 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13825 
    self.authorize = authorize
1135 chandransh 13826 
 
13827 
  def read(self, iprot):
13828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13830 
      return
13831 
    iprot.readStructBegin()
13832 
    while True:
13833 
      (fname, ftype, fid) = iprot.readFieldBegin()
13834 
      if ftype == TType.STOP:
13835 
        break
13836 
      if fid == 1:
13837 
        if ftype == TType.I64:
3064 chandransh 13838 
          self.orderId = iprot.readI64();
1135 chandransh 13839 
        else:
13840 
          iprot.skip(ftype)
13841 
      elif fid == 2:
3064 chandransh 13842 
        if ftype == TType.STRING:
13843 
          self.invoice_number = iprot.readString();
1135 chandransh 13844 
        else:
13845 
          iprot.skip(ftype)
3064 chandransh 13846 
      elif fid == 3:
5411 rajveer 13847 
        if ftype == TType.LIST:
13848 
          self.serialNumber = []
6188 rajveer 13849 
          (_etype270, _size267) = iprot.readListBegin()
13850 
          for _i271 in xrange(_size267):
13851 
            _elem272 = iprot.readString();
13852 
            self.serialNumber.append(_elem272)
5411 rajveer 13853 
          iprot.readListEnd()
3064 chandransh 13854 
        else:
13855 
          iprot.skip(ftype)
13856 
      elif fid == 4:
5411 rajveer 13857 
        if ftype == TType.LIST:
13858 
          self.itemNumber = []
6188 rajveer 13859 
          (_etype276, _size273) = iprot.readListBegin()
13860 
          for _i277 in xrange(_size273):
13861 
            _elem278 = iprot.readString();
13862 
            self.itemNumber.append(_elem278)
5411 rajveer 13863 
          iprot.readListEnd()
3064 chandransh 13864 
        else:
13865 
          iprot.skip(ftype)
13866 
      elif fid == 5:
13867 
        if ftype == TType.STRING:
4283 anupam.sin 13868 
          self.billed_by = iprot.readString();
3064 chandransh 13869 
        else:
13870 
          iprot.skip(ftype)
13871 
      elif fid == 6:
13872 
        if ftype == TType.I64:
4283 anupam.sin 13873 
          self.jacketNumber = iprot.readI64();
13874 
        else:
13875 
          iprot.skip(ftype)
13876 
      elif fid == 7:
13877 
        if ftype == TType.I64:
3064 chandransh 13878 
          self.billingType = iprot.readI64();
13879 
        else:
13880 
          iprot.skip(ftype)
4283 anupam.sin 13881 
      elif fid == 8:
13882 
        if ftype == TType.I64:
5110 mandeep.dh 13883 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13884 
        else:
13885 
          iprot.skip(ftype)
4763 rajveer 13886 
      elif fid == 9:
13887 
        if ftype == TType.BOOL:
13888 
          self.authorize = iprot.readBool();
13889 
        else:
13890 
          iprot.skip(ftype)
1246 chandransh 13891 
      else:
13892 
        iprot.skip(ftype)
13893 
      iprot.readFieldEnd()
13894 
    iprot.readStructEnd()
13895 
 
13896 
  def write(self, oprot):
13897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13899 
      return
4283 anupam.sin 13900 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13901 
    if self.orderId is not None:
3064 chandransh 13902 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13903 
      oprot.writeI64(self.orderId)
1246 chandransh 13904 
      oprot.writeFieldEnd()
4283 anupam.sin 13905 
    if self.invoice_number is not None:
13906 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13907 
      oprot.writeString(self.invoice_number)
1246 chandransh 13908 
      oprot.writeFieldEnd()
4658 mandeep.dh 13909 
    if self.serialNumber is not None:
5411 rajveer 13910 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13911 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13912 
      for iter279 in self.serialNumber:
13913 
        oprot.writeString(iter279)
5411 rajveer 13914 
      oprot.writeListEnd()
3064 chandransh 13915 
      oprot.writeFieldEnd()
3431 rajveer 13916 
    if self.itemNumber is not None:
5411 rajveer 13917 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13918 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13919 
      for iter280 in self.itemNumber:
13920 
        oprot.writeString(iter280)
5411 rajveer 13921 
      oprot.writeListEnd()
3064 chandransh 13922 
      oprot.writeFieldEnd()
4283 anupam.sin 13923 
    if self.billed_by is not None:
13924 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13925 
      oprot.writeString(self.billed_by)
3064 chandransh 13926 
      oprot.writeFieldEnd()
4283 anupam.sin 13927 
    if self.jacketNumber is not None:
13928 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13929 
      oprot.writeI64(self.jacketNumber)
13930 
      oprot.writeFieldEnd()
3431 rajveer 13931 
    if self.billingType is not None:
4283 anupam.sin 13932 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13933 
      oprot.writeI64(self.billingType)
13934 
      oprot.writeFieldEnd()
5110 mandeep.dh 13935 
    if self.fulfilmentWarehouseId is not None:
13936 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13937 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13938 
      oprot.writeFieldEnd()
4763 rajveer 13939 
    if self.authorize is not None:
13940 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13941 
      oprot.writeBool(self.authorize)
13942 
      oprot.writeFieldEnd()
1246 chandransh 13943 
    oprot.writeFieldStop()
13944 
    oprot.writeStructEnd()
13945 
 
3431 rajveer 13946 
  def validate(self):
13947 
    return
13948 
 
13949 
 
1246 chandransh 13950 
  def __repr__(self):
13951 
    L = ['%s=%r' % (key, value)
13952 
      for key, value in self.__dict__.iteritems()]
13953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13954 
 
13955 
  def __eq__(self, other):
13956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13957 
 
13958 
  def __ne__(self, other):
13959 
    return not (self == other)
13960 
 
4283 anupam.sin 13961 
class addBillingDetails_result:
1246 chandransh 13962 
  """
13963 
  Attributes:
3064 chandransh 13964 
   - success
1246 chandransh 13965 
   - ex
13966 
  """
13967 
 
13968 
  thrift_spec = (
3064 chandransh 13969 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13970 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13971 
  )
13972 
 
3064 chandransh 13973 
  def __init__(self, success=None, ex=None,):
13974 
    self.success = success
1246 chandransh 13975 
    self.ex = ex
13976 
 
13977 
  def read(self, iprot):
13978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13980 
      return
13981 
    iprot.readStructBegin()
13982 
    while True:
13983 
      (fname, ftype, fid) = iprot.readFieldBegin()
13984 
      if ftype == TType.STOP:
13985 
        break
3064 chandransh 13986 
      if fid == 0:
13987 
        if ftype == TType.BOOL:
13988 
          self.success = iprot.readBool();
13989 
        else:
13990 
          iprot.skip(ftype)
13991 
      elif fid == 1:
1246 chandransh 13992 
        if ftype == TType.STRUCT:
13993 
          self.ex = TransactionServiceException()
13994 
          self.ex.read(iprot)
13995 
        else:
13996 
          iprot.skip(ftype)
13997 
      else:
13998 
        iprot.skip(ftype)
13999 
      iprot.readFieldEnd()
14000 
    iprot.readStructEnd()
14001 
 
14002 
  def write(self, oprot):
14003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14005 
      return
4283 anupam.sin 14006 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14007 
    if self.success is not None:
3064 chandransh 14008 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14009 
      oprot.writeBool(self.success)
14010 
      oprot.writeFieldEnd()
3431 rajveer 14011 
    if self.ex is not None:
1246 chandransh 14012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14013 
      self.ex.write(oprot)
14014 
      oprot.writeFieldEnd()
14015 
    oprot.writeFieldStop()
14016 
    oprot.writeStructEnd()
14017 
 
3431 rajveer 14018 
  def validate(self):
14019 
    return
14020 
 
14021 
 
1246 chandransh 14022 
  def __repr__(self):
14023 
    L = ['%s=%r' % (key, value)
14024 
      for key, value in self.__dict__.iteritems()]
14025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14026 
 
14027 
  def __eq__(self, other):
14028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14029 
 
14030 
  def __ne__(self, other):
14031 
    return not (self == other)
14032 
 
4579 rajveer 14033 
class addInvoiceNumber_args:
14034 
  """
14035 
  Attributes:
14036 
   - orderId
14037 
   - invoiceNumber
4763 rajveer 14038 
   - color
6756 amar.kumar 14039 
   - serialNumber
14040 
   - itemNumber
4579 rajveer 14041 
  """
14042 
 
14043 
  thrift_spec = (
14044 
    None, # 0
14045 
    (1, TType.I64, 'orderId', None, None, ), # 1
14046 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14047 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14048 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14049 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14050 
  )
14051 
 
6756 amar.kumar 14052 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14053 
    self.orderId = orderId
14054 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14055 
    self.color = color
6756 amar.kumar 14056 
    self.serialNumber = serialNumber
14057 
    self.itemNumber = itemNumber
4579 rajveer 14058 
 
14059 
  def read(self, iprot):
14060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14062 
      return
14063 
    iprot.readStructBegin()
14064 
    while True:
14065 
      (fname, ftype, fid) = iprot.readFieldBegin()
14066 
      if ftype == TType.STOP:
14067 
        break
14068 
      if fid == 1:
14069 
        if ftype == TType.I64:
14070 
          self.orderId = iprot.readI64();
14071 
        else:
14072 
          iprot.skip(ftype)
14073 
      elif fid == 2:
14074 
        if ftype == TType.STRING:
14075 
          self.invoiceNumber = iprot.readString();
14076 
        else:
14077 
          iprot.skip(ftype)
4763 rajveer 14078 
      elif fid == 3:
14079 
        if ftype == TType.STRING:
14080 
          self.color = iprot.readString();
14081 
        else:
14082 
          iprot.skip(ftype)
6756 amar.kumar 14083 
      elif fid == 4:
14084 
        if ftype == TType.STRING:
14085 
          self.serialNumber = iprot.readString();
14086 
        else:
14087 
          iprot.skip(ftype)
14088 
      elif fid == 5:
14089 
        if ftype == TType.STRING:
14090 
          self.itemNumber = iprot.readString();
14091 
        else:
14092 
          iprot.skip(ftype)
4579 rajveer 14093 
      else:
14094 
        iprot.skip(ftype)
14095 
      iprot.readFieldEnd()
14096 
    iprot.readStructEnd()
14097 
 
14098 
  def write(self, oprot):
14099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14101 
      return
14102 
    oprot.writeStructBegin('addInvoiceNumber_args')
14103 
    if self.orderId is not None:
14104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14105 
      oprot.writeI64(self.orderId)
14106 
      oprot.writeFieldEnd()
14107 
    if self.invoiceNumber is not None:
14108 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14109 
      oprot.writeString(self.invoiceNumber)
14110 
      oprot.writeFieldEnd()
4763 rajveer 14111 
    if self.color is not None:
14112 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14113 
      oprot.writeString(self.color)
14114 
      oprot.writeFieldEnd()
6756 amar.kumar 14115 
    if self.serialNumber is not None:
14116 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14117 
      oprot.writeString(self.serialNumber)
14118 
      oprot.writeFieldEnd()
14119 
    if self.itemNumber is not None:
14120 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14121 
      oprot.writeString(self.itemNumber)
14122 
      oprot.writeFieldEnd()
4579 rajveer 14123 
    oprot.writeFieldStop()
14124 
    oprot.writeStructEnd()
14125 
 
14126 
  def validate(self):
14127 
    return
14128 
 
14129 
 
14130 
  def __repr__(self):
14131 
    L = ['%s=%r' % (key, value)
14132 
      for key, value in self.__dict__.iteritems()]
14133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14134 
 
14135 
  def __eq__(self, other):
14136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14137 
 
14138 
  def __ne__(self, other):
14139 
    return not (self == other)
14140 
 
14141 
class addInvoiceNumber_result:
14142 
  """
14143 
  Attributes:
14144 
   - ex
14145 
  """
14146 
 
14147 
  thrift_spec = (
14148 
    None, # 0
14149 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14150 
  )
14151 
 
14152 
  def __init__(self, ex=None,):
14153 
    self.ex = ex
14154 
 
14155 
  def read(self, iprot):
14156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14158 
      return
14159 
    iprot.readStructBegin()
14160 
    while True:
14161 
      (fname, ftype, fid) = iprot.readFieldBegin()
14162 
      if ftype == TType.STOP:
14163 
        break
14164 
      if fid == 1:
14165 
        if ftype == TType.STRUCT:
14166 
          self.ex = TransactionServiceException()
14167 
          self.ex.read(iprot)
14168 
        else:
14169 
          iprot.skip(ftype)
14170 
      else:
14171 
        iprot.skip(ftype)
14172 
      iprot.readFieldEnd()
14173 
    iprot.readStructEnd()
14174 
 
14175 
  def write(self, oprot):
14176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14178 
      return
14179 
    oprot.writeStructBegin('addInvoiceNumber_result')
14180 
    if self.ex is not None:
14181 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14182 
      self.ex.write(oprot)
14183 
      oprot.writeFieldEnd()
14184 
    oprot.writeFieldStop()
14185 
    oprot.writeStructEnd()
14186 
 
14187 
  def validate(self):
14188 
    return
14189 
 
14190 
 
14191 
  def __repr__(self):
14192 
    L = ['%s=%r' % (key, value)
14193 
      for key, value in self.__dict__.iteritems()]
14194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14195 
 
14196 
  def __eq__(self, other):
14197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14198 
 
14199 
  def __ne__(self, other):
14200 
    return not (self == other)
14201 
 
4910 phani.kuma 14202 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14203 
  """
14204 
  Attributes:
3064 chandransh 14205 
   - warehouseId
1408 ankur.sing 14206 
   - providerId
3064 chandransh 14207 
   - cod
4910 phani.kuma 14208 
   - orderIds
1408 ankur.sing 14209 
  """
14210 
 
14211 
  thrift_spec = (
14212 
    None, # 0
3064 chandransh 14213 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14214 
    (2, TType.I64, 'providerId', None, None, ), # 2
14215 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14216 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14217 
  )
14218 
 
4910 phani.kuma 14219 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14220 
    self.warehouseId = warehouseId
1408 ankur.sing 14221 
    self.providerId = providerId
3064 chandransh 14222 
    self.cod = cod
4910 phani.kuma 14223 
    self.orderIds = orderIds
1408 ankur.sing 14224 
 
14225 
  def read(self, iprot):
14226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14228 
      return
14229 
    iprot.readStructBegin()
14230 
    while True:
14231 
      (fname, ftype, fid) = iprot.readFieldBegin()
14232 
      if ftype == TType.STOP:
14233 
        break
14234 
      if fid == 1:
14235 
        if ftype == TType.I64:
3064 chandransh 14236 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14237 
        else:
14238 
          iprot.skip(ftype)
14239 
      elif fid == 2:
14240 
        if ftype == TType.I64:
3064 chandransh 14241 
          self.providerId = iprot.readI64();
1408 ankur.sing 14242 
        else:
14243 
          iprot.skip(ftype)
3064 chandransh 14244 
      elif fid == 3:
14245 
        if ftype == TType.BOOL:
14246 
          self.cod = iprot.readBool();
14247 
        else:
14248 
          iprot.skip(ftype)
4910 phani.kuma 14249 
      elif fid == 4:
14250 
        if ftype == TType.LIST:
14251 
          self.orderIds = []
6188 rajveer 14252 
          (_etype284, _size281) = iprot.readListBegin()
14253 
          for _i285 in xrange(_size281):
14254 
            _elem286 = iprot.readI64();
14255 
            self.orderIds.append(_elem286)
4910 phani.kuma 14256 
          iprot.readListEnd()
14257 
        else:
14258 
          iprot.skip(ftype)
1408 ankur.sing 14259 
      else:
14260 
        iprot.skip(ftype)
14261 
      iprot.readFieldEnd()
14262 
    iprot.readStructEnd()
14263 
 
14264 
  def write(self, oprot):
14265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14267 
      return
4910 phani.kuma 14268 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14269 
    if self.warehouseId is not None:
3064 chandransh 14270 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14271 
      oprot.writeI64(self.warehouseId)
14272 
      oprot.writeFieldEnd()
3431 rajveer 14273 
    if self.providerId is not None:
3064 chandransh 14274 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14275 
      oprot.writeI64(self.providerId)
14276 
      oprot.writeFieldEnd()
3431 rajveer 14277 
    if self.cod is not None:
3064 chandransh 14278 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14279 
      oprot.writeBool(self.cod)
1408 ankur.sing 14280 
      oprot.writeFieldEnd()
4910 phani.kuma 14281 
    if self.orderIds is not None:
14282 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14283 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14284 
      for iter287 in self.orderIds:
14285 
        oprot.writeI64(iter287)
4910 phani.kuma 14286 
      oprot.writeListEnd()
14287 
      oprot.writeFieldEnd()
1408 ankur.sing 14288 
    oprot.writeFieldStop()
14289 
    oprot.writeStructEnd()
14290 
 
3431 rajveer 14291 
  def validate(self):
14292 
    return
14293 
 
14294 
 
1408 ankur.sing 14295 
  def __repr__(self):
14296 
    L = ['%s=%r' % (key, value)
14297 
      for key, value in self.__dict__.iteritems()]
14298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14299 
 
14300 
  def __eq__(self, other):
14301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14302 
 
14303 
  def __ne__(self, other):
14304 
    return not (self == other)
14305 
 
4910 phani.kuma 14306 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14307 
  """
14308 
  Attributes:
14309 
   - success
3064 chandransh 14310 
   - ex
1408 ankur.sing 14311 
  """
14312 
 
14313 
  thrift_spec = (
3064 chandransh 14314 
    (0, TType.BOOL, 'success', None, None, ), # 0
14315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14316 
  )
14317 
 
3064 chandransh 14318 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14319 
    self.success = success
3064 chandransh 14320 
    self.ex = ex
1408 ankur.sing 14321 
 
14322 
  def read(self, iprot):
14323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14325 
      return
14326 
    iprot.readStructBegin()
14327 
    while True:
14328 
      (fname, ftype, fid) = iprot.readFieldBegin()
14329 
      if ftype == TType.STOP:
14330 
        break
14331 
      if fid == 0:
3064 chandransh 14332 
        if ftype == TType.BOOL:
14333 
          self.success = iprot.readBool();
1408 ankur.sing 14334 
        else:
14335 
          iprot.skip(ftype)
3064 chandransh 14336 
      elif fid == 1:
14337 
        if ftype == TType.STRUCT:
14338 
          self.ex = TransactionServiceException()
14339 
          self.ex.read(iprot)
14340 
        else:
14341 
          iprot.skip(ftype)
1408 ankur.sing 14342 
      else:
14343 
        iprot.skip(ftype)
14344 
      iprot.readFieldEnd()
14345 
    iprot.readStructEnd()
14346 
 
14347 
  def write(self, oprot):
14348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14350 
      return
4910 phani.kuma 14351 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14352 
    if self.success is not None:
3064 chandransh 14353 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14354 
      oprot.writeBool(self.success)
1408 ankur.sing 14355 
      oprot.writeFieldEnd()
3431 rajveer 14356 
    if self.ex is not None:
3064 chandransh 14357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14358 
      self.ex.write(oprot)
14359 
      oprot.writeFieldEnd()
1408 ankur.sing 14360 
    oprot.writeFieldStop()
14361 
    oprot.writeStructEnd()
14362 
 
3431 rajveer 14363 
  def validate(self):
14364 
    return
14365 
 
14366 
 
1408 ankur.sing 14367 
  def __repr__(self):
14368 
    L = ['%s=%r' % (key, value)
14369 
      for key, value in self.__dict__.iteritems()]
14370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14371 
 
14372 
  def __eq__(self, other):
14373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14374 
 
14375 
  def __ne__(self, other):
14376 
    return not (self == other)
14377 
 
5676 rajveer 14378 
class markOrdersAsReturnedFromStore_args:
14379 
  """
14380 
  Attributes:
14381 
   - providerId
14382 
   - orderIds
5713 rajveer 14383 
   - awbs
5676 rajveer 14384 
  """
14385 
 
14386 
  thrift_spec = (
14387 
    None, # 0
14388 
    (1, TType.I64, 'providerId', None, None, ), # 1
14389 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14390 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14391 
  )
14392 
 
5713 rajveer 14393 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14394 
    self.providerId = providerId
14395 
    self.orderIds = orderIds
5713 rajveer 14396 
    self.awbs = awbs
5676 rajveer 14397 
 
14398 
  def read(self, iprot):
14399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14401 
      return
14402 
    iprot.readStructBegin()
14403 
    while True:
14404 
      (fname, ftype, fid) = iprot.readFieldBegin()
14405 
      if ftype == TType.STOP:
14406 
        break
14407 
      if fid == 1:
14408 
        if ftype == TType.I64:
14409 
          self.providerId = iprot.readI64();
14410 
        else:
14411 
          iprot.skip(ftype)
14412 
      elif fid == 2:
14413 
        if ftype == TType.LIST:
14414 
          self.orderIds = []
6188 rajveer 14415 
          (_etype291, _size288) = iprot.readListBegin()
14416 
          for _i292 in xrange(_size288):
14417 
            _elem293 = iprot.readI64();
14418 
            self.orderIds.append(_elem293)
5676 rajveer 14419 
          iprot.readListEnd()
14420 
        else:
14421 
          iprot.skip(ftype)
5713 rajveer 14422 
      elif fid == 3:
14423 
        if ftype == TType.LIST:
14424 
          self.awbs = []
6188 rajveer 14425 
          (_etype297, _size294) = iprot.readListBegin()
14426 
          for _i298 in xrange(_size294):
14427 
            _elem299 = iprot.readString();
14428 
            self.awbs.append(_elem299)
5713 rajveer 14429 
          iprot.readListEnd()
14430 
        else:
14431 
          iprot.skip(ftype)
5676 rajveer 14432 
      else:
14433 
        iprot.skip(ftype)
14434 
      iprot.readFieldEnd()
14435 
    iprot.readStructEnd()
14436 
 
14437 
  def write(self, oprot):
14438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14440 
      return
14441 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14442 
    if self.providerId is not None:
14443 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14444 
      oprot.writeI64(self.providerId)
14445 
      oprot.writeFieldEnd()
14446 
    if self.orderIds is not None:
14447 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14448 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14449 
      for iter300 in self.orderIds:
14450 
        oprot.writeI64(iter300)
5676 rajveer 14451 
      oprot.writeListEnd()
14452 
      oprot.writeFieldEnd()
5713 rajveer 14453 
    if self.awbs is not None:
14454 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14455 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14456 
      for iter301 in self.awbs:
14457 
        oprot.writeString(iter301)
5713 rajveer 14458 
      oprot.writeListEnd()
14459 
      oprot.writeFieldEnd()
5676 rajveer 14460 
    oprot.writeFieldStop()
14461 
    oprot.writeStructEnd()
14462 
 
14463 
  def validate(self):
14464 
    return
14465 
 
14466 
 
14467 
  def __repr__(self):
14468 
    L = ['%s=%r' % (key, value)
14469 
      for key, value in self.__dict__.iteritems()]
14470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14471 
 
14472 
  def __eq__(self, other):
14473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14474 
 
14475 
  def __ne__(self, other):
14476 
    return not (self == other)
14477 
 
14478 
class markOrdersAsReturnedFromStore_result:
14479 
  """
14480 
  Attributes:
14481 
   - success
14482 
   - ex
14483 
  """
14484 
 
14485 
  thrift_spec = (
14486 
    (0, TType.BOOL, 'success', None, None, ), # 0
14487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14488 
  )
14489 
 
14490 
  def __init__(self, success=None, ex=None,):
14491 
    self.success = success
14492 
    self.ex = ex
14493 
 
14494 
  def read(self, iprot):
14495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14497 
      return
14498 
    iprot.readStructBegin()
14499 
    while True:
14500 
      (fname, ftype, fid) = iprot.readFieldBegin()
14501 
      if ftype == TType.STOP:
14502 
        break
14503 
      if fid == 0:
14504 
        if ftype == TType.BOOL:
14505 
          self.success = iprot.readBool();
14506 
        else:
14507 
          iprot.skip(ftype)
14508 
      elif fid == 1:
14509 
        if ftype == TType.STRUCT:
14510 
          self.ex = TransactionServiceException()
14511 
          self.ex.read(iprot)
14512 
        else:
14513 
          iprot.skip(ftype)
14514 
      else:
14515 
        iprot.skip(ftype)
14516 
      iprot.readFieldEnd()
14517 
    iprot.readStructEnd()
14518 
 
14519 
  def write(self, oprot):
14520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14522 
      return
14523 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14524 
    if self.success is not None:
14525 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14526 
      oprot.writeBool(self.success)
14527 
      oprot.writeFieldEnd()
14528 
    if self.ex is not None:
14529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14530 
      self.ex.write(oprot)
14531 
      oprot.writeFieldEnd()
14532 
    oprot.writeFieldStop()
14533 
    oprot.writeStructEnd()
14534 
 
14535 
  def validate(self):
14536 
    return
14537 
 
14538 
 
14539 
  def __repr__(self):
14540 
    L = ['%s=%r' % (key, value)
14541 
      for key, value in self.__dict__.iteritems()]
14542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14543 
 
14544 
  def __eq__(self, other):
14545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14546 
 
14547 
  def __ne__(self, other):
14548 
    return not (self == other)
14549 
 
4910 phani.kuma 14550 
class markOrdersAsPickedUp_args:
4410 rajveer 14551 
  """
14552 
  Attributes:
14553 
   - providerId
4910 phani.kuma 14554 
   - pickupDetails
4410 rajveer 14555 
  """
14556 
 
14557 
  thrift_spec = (
14558 
    None, # 0
4910 phani.kuma 14559 
    (1, TType.I64, 'providerId', None, None, ), # 1
14560 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14561 
  )
14562 
 
4910 phani.kuma 14563 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14564 
    self.providerId = providerId
4910 phani.kuma 14565 
    self.pickupDetails = pickupDetails
4410 rajveer 14566 
 
14567 
  def read(self, iprot):
14568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14570 
      return
14571 
    iprot.readStructBegin()
14572 
    while True:
14573 
      (fname, ftype, fid) = iprot.readFieldBegin()
14574 
      if ftype == TType.STOP:
14575 
        break
14576 
      if fid == 1:
14577 
        if ftype == TType.I64:
4910 phani.kuma 14578 
          self.providerId = iprot.readI64();
4410 rajveer 14579 
        else:
14580 
          iprot.skip(ftype)
14581 
      elif fid == 2:
4910 phani.kuma 14582 
        if ftype == TType.MAP:
14583 
          self.pickupDetails = {}
6188 rajveer 14584 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14585 
          for _i306 in xrange(_size302):
14586 
            _key307 = iprot.readString();
14587 
            _val308 = iprot.readString();
14588 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14589 
          iprot.readMapEnd()
4410 rajveer 14590 
        else:
14591 
          iprot.skip(ftype)
14592 
      else:
14593 
        iprot.skip(ftype)
14594 
      iprot.readFieldEnd()
14595 
    iprot.readStructEnd()
14596 
 
14597 
  def write(self, oprot):
14598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14600 
      return
4910 phani.kuma 14601 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14602 
    if self.providerId is not None:
4910 phani.kuma 14603 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14604 
      oprot.writeI64(self.providerId)
14605 
      oprot.writeFieldEnd()
4910 phani.kuma 14606 
    if self.pickupDetails is not None:
14607 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14608 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14609 
      for kiter309,viter310 in self.pickupDetails.items():
14610 
        oprot.writeString(kiter309)
14611 
        oprot.writeString(viter310)
4910 phani.kuma 14612 
      oprot.writeMapEnd()
4410 rajveer 14613 
      oprot.writeFieldEnd()
14614 
    oprot.writeFieldStop()
14615 
    oprot.writeStructEnd()
14616 
 
14617 
  def validate(self):
14618 
    return
14619 
 
14620 
 
14621 
  def __repr__(self):
14622 
    L = ['%s=%r' % (key, value)
14623 
      for key, value in self.__dict__.iteritems()]
14624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14625 
 
14626 
  def __eq__(self, other):
14627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14628 
 
14629 
  def __ne__(self, other):
14630 
    return not (self == other)
14631 
 
4910 phani.kuma 14632 
class markOrdersAsPickedUp_result:
4410 rajveer 14633 
  """
14634 
  Attributes:
14635 
   - ex
14636 
  """
14637 
 
14638 
  thrift_spec = (
4910 phani.kuma 14639 
    None, # 0
4410 rajveer 14640 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14641 
  )
14642 
 
4910 phani.kuma 14643 
  def __init__(self, ex=None,):
4410 rajveer 14644 
    self.ex = ex
14645 
 
14646 
  def read(self, iprot):
14647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14649 
      return
14650 
    iprot.readStructBegin()
14651 
    while True:
14652 
      (fname, ftype, fid) = iprot.readFieldBegin()
14653 
      if ftype == TType.STOP:
14654 
        break
4910 phani.kuma 14655 
      if fid == 1:
4410 rajveer 14656 
        if ftype == TType.STRUCT:
14657 
          self.ex = TransactionServiceException()
14658 
          self.ex.read(iprot)
14659 
        else:
14660 
          iprot.skip(ftype)
14661 
      else:
14662 
        iprot.skip(ftype)
14663 
      iprot.readFieldEnd()
14664 
    iprot.readStructEnd()
14665 
 
14666 
  def write(self, oprot):
14667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14669 
      return
4910 phani.kuma 14670 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14671 
    if self.ex is not None:
14672 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14673 
      self.ex.write(oprot)
14674 
      oprot.writeFieldEnd()
14675 
    oprot.writeFieldStop()
14676 
    oprot.writeStructEnd()
14677 
 
14678 
  def validate(self):
14679 
    return
14680 
 
14681 
 
14682 
  def __repr__(self):
14683 
    L = ['%s=%r' % (key, value)
14684 
      for key, value in self.__dict__.iteritems()]
14685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14686 
 
14687 
  def __eq__(self, other):
14688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14689 
 
14690 
  def __ne__(self, other):
14691 
    return not (self == other)
14692 
 
4910 phani.kuma 14693 
class getOrdersNotPickedUp_args:
304 ashish 14694 
  """
14695 
  Attributes:
3064 chandransh 14696 
   - providerId
304 ashish 14697 
  """
94 ashish 14698 
 
304 ashish 14699 
  thrift_spec = (
14700 
    None, # 0
3064 chandransh 14701 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14702 
  )
14703 
 
4910 phani.kuma 14704 
  def __init__(self, providerId=None,):
3064 chandransh 14705 
    self.providerId = providerId
304 ashish 14706 
 
14707 
  def read(self, iprot):
14708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14710 
      return
14711 
    iprot.readStructBegin()
14712 
    while True:
14713 
      (fname, ftype, fid) = iprot.readFieldBegin()
14714 
      if ftype == TType.STOP:
14715 
        break
14716 
      if fid == 1:
14717 
        if ftype == TType.I64:
3064 chandransh 14718 
          self.providerId = iprot.readI64();
304 ashish 14719 
        else:
14720 
          iprot.skip(ftype)
14721 
      else:
14722 
        iprot.skip(ftype)
14723 
      iprot.readFieldEnd()
14724 
    iprot.readStructEnd()
14725 
 
14726 
  def write(self, oprot):
14727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14729 
      return
4910 phani.kuma 14730 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14731 
    if self.providerId is not None:
3064 chandransh 14732 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14733 
      oprot.writeI64(self.providerId)
304 ashish 14734 
      oprot.writeFieldEnd()
14735 
    oprot.writeFieldStop()
14736 
    oprot.writeStructEnd()
14737 
 
3431 rajveer 14738 
  def validate(self):
14739 
    return
14740 
 
14741 
 
304 ashish 14742 
  def __repr__(self):
14743 
    L = ['%s=%r' % (key, value)
14744 
      for key, value in self.__dict__.iteritems()]
14745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14746 
 
14747 
  def __eq__(self, other):
14748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14749 
 
14750 
  def __ne__(self, other):
14751 
    return not (self == other)
14752 
 
4910 phani.kuma 14753 
class getOrdersNotPickedUp_result:
304 ashish 14754 
  """
14755 
  Attributes:
14756 
   - success
14757 
  """
14758 
 
14759 
  thrift_spec = (
3064 chandransh 14760 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14761 
  )
14762 
 
4910 phani.kuma 14763 
  def __init__(self, success=None,):
304 ashish 14764 
    self.success = success
14765 
 
14766 
  def read(self, iprot):
14767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14769 
      return
14770 
    iprot.readStructBegin()
14771 
    while True:
14772 
      (fname, ftype, fid) = iprot.readFieldBegin()
14773 
      if ftype == TType.STOP:
14774 
        break
14775 
      if fid == 0:
14776 
        if ftype == TType.LIST:
14777 
          self.success = []
6188 rajveer 14778 
          (_etype314, _size311) = iprot.readListBegin()
14779 
          for _i315 in xrange(_size311):
14780 
            _elem316 = Order()
14781 
            _elem316.read(iprot)
14782 
            self.success.append(_elem316)
304 ashish 14783 
          iprot.readListEnd()
14784 
        else:
14785 
          iprot.skip(ftype)
14786 
      else:
14787 
        iprot.skip(ftype)
14788 
      iprot.readFieldEnd()
14789 
    iprot.readStructEnd()
14790 
 
14791 
  def write(self, oprot):
14792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14794 
      return
4910 phani.kuma 14795 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14796 
    if self.success is not None:
304 ashish 14797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14799 
      for iter317 in self.success:
14800 
        iter317.write(oprot)
304 ashish 14801 
      oprot.writeListEnd()
14802 
      oprot.writeFieldEnd()
14803 
    oprot.writeFieldStop()
14804 
    oprot.writeStructEnd()
14805 
 
3431 rajveer 14806 
  def validate(self):
14807 
    return
14808 
 
14809 
 
304 ashish 14810 
  def __repr__(self):
14811 
    L = ['%s=%r' % (key, value)
14812 
      for key, value in self.__dict__.iteritems()]
14813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14814 
 
14815 
  def __eq__(self, other):
14816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14817 
 
14818 
  def __ne__(self, other):
14819 
    return not (self == other)
14820 
 
3064 chandransh 14821 
class markOrdersAsDelivered_args:
304 ashish 14822 
  """
14823 
  Attributes:
3064 chandransh 14824 
   - providerId
14825 
   - deliveredOrders
304 ashish 14826 
  """
14827 
 
14828 
  thrift_spec = (
14829 
    None, # 0
3064 chandransh 14830 
    (1, TType.I64, 'providerId', None, None, ), # 1
14831 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14832 
  )
14833 
 
3064 chandransh 14834 
  def __init__(self, providerId=None, deliveredOrders=None,):
14835 
    self.providerId = providerId
14836 
    self.deliveredOrders = deliveredOrders
304 ashish 14837 
 
14838 
  def read(self, iprot):
14839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14841 
      return
14842 
    iprot.readStructBegin()
14843 
    while True:
14844 
      (fname, ftype, fid) = iprot.readFieldBegin()
14845 
      if ftype == TType.STOP:
14846 
        break
14847 
      if fid == 1:
14848 
        if ftype == TType.I64:
3064 chandransh 14849 
          self.providerId = iprot.readI64();
304 ashish 14850 
        else:
14851 
          iprot.skip(ftype)
14852 
      elif fid == 2:
3064 chandransh 14853 
        if ftype == TType.MAP:
14854 
          self.deliveredOrders = {}
6188 rajveer 14855 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14856 
          for _i322 in xrange(_size318):
14857 
            _key323 = iprot.readString();
14858 
            _val324 = iprot.readString();
14859 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14860 
          iprot.readMapEnd()
304 ashish 14861 
        else:
14862 
          iprot.skip(ftype)
14863 
      else:
14864 
        iprot.skip(ftype)
14865 
      iprot.readFieldEnd()
14866 
    iprot.readStructEnd()
14867 
 
14868 
  def write(self, oprot):
14869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14871 
      return
3064 chandransh 14872 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14873 
    if self.providerId is not None:
3064 chandransh 14874 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14875 
      oprot.writeI64(self.providerId)
304 ashish 14876 
      oprot.writeFieldEnd()
3431 rajveer 14877 
    if self.deliveredOrders is not None:
3064 chandransh 14878 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14879 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14880 
      for kiter325,viter326 in self.deliveredOrders.items():
14881 
        oprot.writeString(kiter325)
14882 
        oprot.writeString(viter326)
3064 chandransh 14883 
      oprot.writeMapEnd()
304 ashish 14884 
      oprot.writeFieldEnd()
14885 
    oprot.writeFieldStop()
14886 
    oprot.writeStructEnd()
14887 
 
3431 rajveer 14888 
  def validate(self):
14889 
    return
14890 
 
14891 
 
304 ashish 14892 
  def __repr__(self):
14893 
    L = ['%s=%r' % (key, value)
14894 
      for key, value in self.__dict__.iteritems()]
14895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14896 
 
14897 
  def __eq__(self, other):
14898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14899 
 
14900 
  def __ne__(self, other):
14901 
    return not (self == other)
14902 
 
3064 chandransh 14903 
class markOrdersAsDelivered_result:
14904 
  """
14905 
  Attributes:
14906 
   - ex
14907 
  """
304 ashish 14908 
 
14909 
  thrift_spec = (
3064 chandransh 14910 
    None, # 0
14911 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14912 
  )
14913 
 
3064 chandransh 14914 
  def __init__(self, ex=None,):
14915 
    self.ex = ex
304 ashish 14916 
 
1596 ankur.sing 14917 
  def read(self, iprot):
14918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14920 
      return
14921 
    iprot.readStructBegin()
14922 
    while True:
14923 
      (fname, ftype, fid) = iprot.readFieldBegin()
14924 
      if ftype == TType.STOP:
14925 
        break
3064 chandransh 14926 
      if fid == 1:
14927 
        if ftype == TType.STRUCT:
14928 
          self.ex = TransactionServiceException()
14929 
          self.ex.read(iprot)
14930 
        else:
14931 
          iprot.skip(ftype)
1596 ankur.sing 14932 
      else:
14933 
        iprot.skip(ftype)
14934 
      iprot.readFieldEnd()
14935 
    iprot.readStructEnd()
14936 
 
14937 
  def write(self, oprot):
14938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14940 
      return
3064 chandransh 14941 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14942 
    if self.ex is not None:
3064 chandransh 14943 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14944 
      self.ex.write(oprot)
14945 
      oprot.writeFieldEnd()
1596 ankur.sing 14946 
    oprot.writeFieldStop()
14947 
    oprot.writeStructEnd()
14948 
 
3431 rajveer 14949 
  def validate(self):
14950 
    return
14951 
 
14952 
 
1596 ankur.sing 14953 
  def __repr__(self):
14954 
    L = ['%s=%r' % (key, value)
14955 
      for key, value in self.__dict__.iteritems()]
14956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14957 
 
14958 
  def __eq__(self, other):
14959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14960 
 
14961 
  def __ne__(self, other):
14962 
    return not (self == other)
14963 
 
4910 phani.kuma 14964 
class markAsRTOrders_args:
1596 ankur.sing 14965 
  """
14966 
  Attributes:
3064 chandransh 14967 
   - providerId
14968 
   - returnedOrders
1596 ankur.sing 14969 
  """
14970 
 
14971 
  thrift_spec = (
3064 chandransh 14972 
    None, # 0
14973 
    (1, TType.I64, 'providerId', None, None, ), # 1
14974 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14975 
  )
14976 
 
3064 chandransh 14977 
  def __init__(self, providerId=None, returnedOrders=None,):
14978 
    self.providerId = providerId
14979 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14980 
 
14981 
  def read(self, iprot):
14982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14984 
      return
14985 
    iprot.readStructBegin()
14986 
    while True:
14987 
      (fname, ftype, fid) = iprot.readFieldBegin()
14988 
      if ftype == TType.STOP:
14989 
        break
3064 chandransh 14990 
      if fid == 1:
1596 ankur.sing 14991 
        if ftype == TType.I64:
3064 chandransh 14992 
          self.providerId = iprot.readI64();
1596 ankur.sing 14993 
        else:
14994 
          iprot.skip(ftype)
3064 chandransh 14995 
      elif fid == 2:
14996 
        if ftype == TType.MAP:
14997 
          self.returnedOrders = {}
6188 rajveer 14998 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14999 
          for _i331 in xrange(_size327):
15000 
            _key332 = iprot.readString();
15001 
            _val333 = iprot.readString();
15002 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15003 
          iprot.readMapEnd()
15004 
        else:
15005 
          iprot.skip(ftype)
1596 ankur.sing 15006 
      else:
15007 
        iprot.skip(ftype)
15008 
      iprot.readFieldEnd()
15009 
    iprot.readStructEnd()
15010 
 
15011 
  def write(self, oprot):
15012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15014 
      return
4910 phani.kuma 15015 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15016 
    if self.providerId is not None:
3064 chandransh 15017 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15018 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15019 
      oprot.writeFieldEnd()
3431 rajveer 15020 
    if self.returnedOrders is not None:
3064 chandransh 15021 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15022 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15023 
      for kiter334,viter335 in self.returnedOrders.items():
15024 
        oprot.writeString(kiter334)
15025 
        oprot.writeString(viter335)
3064 chandransh 15026 
      oprot.writeMapEnd()
15027 
      oprot.writeFieldEnd()
1596 ankur.sing 15028 
    oprot.writeFieldStop()
15029 
    oprot.writeStructEnd()
15030 
 
3431 rajveer 15031 
  def validate(self):
15032 
    return
15033 
 
15034 
 
1596 ankur.sing 15035 
  def __repr__(self):
15036 
    L = ['%s=%r' % (key, value)
15037 
      for key, value in self.__dict__.iteritems()]
15038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15039 
 
15040 
  def __eq__(self, other):
15041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15042 
 
15043 
  def __ne__(self, other):
15044 
    return not (self == other)
15045 
 
4910 phani.kuma 15046 
class markAsRTOrders_result:
3064 chandransh 15047 
  """
15048 
  Attributes:
15049 
   - ex
15050 
  """
1596 ankur.sing 15051 
 
1627 ankur.sing 15052 
  thrift_spec = (
3064 chandransh 15053 
    None, # 0
15054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15055 
  )
15056 
 
3064 chandransh 15057 
  def __init__(self, ex=None,):
15058 
    self.ex = ex
15059 
 
1627 ankur.sing 15060 
  def read(self, iprot):
15061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15063 
      return
15064 
    iprot.readStructBegin()
15065 
    while True:
15066 
      (fname, ftype, fid) = iprot.readFieldBegin()
15067 
      if ftype == TType.STOP:
15068 
        break
3064 chandransh 15069 
      if fid == 1:
15070 
        if ftype == TType.STRUCT:
15071 
          self.ex = TransactionServiceException()
15072 
          self.ex.read(iprot)
15073 
        else:
15074 
          iprot.skip(ftype)
1627 ankur.sing 15075 
      else:
15076 
        iprot.skip(ftype)
15077 
      iprot.readFieldEnd()
15078 
    iprot.readStructEnd()
15079 
 
15080 
  def write(self, oprot):
15081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15083 
      return
4910 phani.kuma 15084 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15085 
    if self.ex is not None:
3064 chandransh 15086 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15087 
      self.ex.write(oprot)
15088 
      oprot.writeFieldEnd()
1627 ankur.sing 15089 
    oprot.writeFieldStop()
15090 
    oprot.writeStructEnd()
15091 
 
3431 rajveer 15092 
  def validate(self):
15093 
    return
15094 
 
15095 
 
1627 ankur.sing 15096 
  def __repr__(self):
15097 
    L = ['%s=%r' % (key, value)
15098 
      for key, value in self.__dict__.iteritems()]
15099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15100 
 
15101 
  def __eq__(self, other):
15102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15103 
 
15104 
  def __ne__(self, other):
15105 
    return not (self == other)
15106 
 
4910 phani.kuma 15107 
class getRTOrders_args:
15108 
  """
15109 
  Attributes:
15110 
   - providerId
15111 
  """
15112 
 
15113 
  thrift_spec = (
15114 
    None, # 0
15115 
    (1, TType.I64, 'providerId', None, None, ), # 1
15116 
  )
15117 
 
15118 
  def __init__(self, providerId=None,):
15119 
    self.providerId = providerId
15120 
 
15121 
  def read(self, iprot):
15122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15124 
      return
15125 
    iprot.readStructBegin()
15126 
    while True:
15127 
      (fname, ftype, fid) = iprot.readFieldBegin()
15128 
      if ftype == TType.STOP:
15129 
        break
15130 
      if fid == 1:
15131 
        if ftype == TType.I64:
15132 
          self.providerId = iprot.readI64();
15133 
        else:
15134 
          iprot.skip(ftype)
15135 
      else:
15136 
        iprot.skip(ftype)
15137 
      iprot.readFieldEnd()
15138 
    iprot.readStructEnd()
15139 
 
15140 
  def write(self, oprot):
15141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15143 
      return
15144 
    oprot.writeStructBegin('getRTOrders_args')
15145 
    if self.providerId is not None:
15146 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15147 
      oprot.writeI64(self.providerId)
15148 
      oprot.writeFieldEnd()
15149 
    oprot.writeFieldStop()
15150 
    oprot.writeStructEnd()
15151 
 
15152 
  def validate(self):
15153 
    return
15154 
 
15155 
 
15156 
  def __repr__(self):
15157 
    L = ['%s=%r' % (key, value)
15158 
      for key, value in self.__dict__.iteritems()]
15159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15160 
 
15161 
  def __eq__(self, other):
15162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15163 
 
15164 
  def __ne__(self, other):
15165 
    return not (self == other)
15166 
 
15167 
class getRTOrders_result:
15168 
  """
15169 
  Attributes:
15170 
   - success
15171 
  """
15172 
 
15173 
  thrift_spec = (
15174 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15175 
  )
15176 
 
15177 
  def __init__(self, success=None,):
15178 
    self.success = success
15179 
 
15180 
  def read(self, iprot):
15181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15183 
      return
15184 
    iprot.readStructBegin()
15185 
    while True:
15186 
      (fname, ftype, fid) = iprot.readFieldBegin()
15187 
      if ftype == TType.STOP:
15188 
        break
15189 
      if fid == 0:
15190 
        if ftype == TType.LIST:
15191 
          self.success = []
6188 rajveer 15192 
          (_etype339, _size336) = iprot.readListBegin()
15193 
          for _i340 in xrange(_size336):
15194 
            _elem341 = Order()
15195 
            _elem341.read(iprot)
15196 
            self.success.append(_elem341)
4910 phani.kuma 15197 
          iprot.readListEnd()
15198 
        else:
15199 
          iprot.skip(ftype)
15200 
      else:
15201 
        iprot.skip(ftype)
15202 
      iprot.readFieldEnd()
15203 
    iprot.readStructEnd()
15204 
 
15205 
  def write(self, oprot):
15206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15208 
      return
15209 
    oprot.writeStructBegin('getRTOrders_result')
15210 
    if self.success is not None:
15211 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15212 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15213 
      for iter342 in self.success:
15214 
        iter342.write(oprot)
4910 phani.kuma 15215 
      oprot.writeListEnd()
15216 
      oprot.writeFieldEnd()
15217 
    oprot.writeFieldStop()
15218 
    oprot.writeStructEnd()
15219 
 
15220 
  def validate(self):
15221 
    return
15222 
 
15223 
 
15224 
  def __repr__(self):
15225 
    L = ['%s=%r' % (key, value)
15226 
      for key, value in self.__dict__.iteritems()]
15227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15228 
 
15229 
  def __eq__(self, other):
15230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15231 
 
15232 
  def __ne__(self, other):
15233 
    return not (self == other)
15234 
 
3064 chandransh 15235 
class updateNonDeliveryReason_args:
1627 ankur.sing 15236 
  """
15237 
  Attributes:
3064 chandransh 15238 
   - providerId
15239 
   - undeliveredOrders
1627 ankur.sing 15240 
  """
15241 
 
15242 
  thrift_spec = (
3064 chandransh 15243 
    None, # 0
15244 
    (1, TType.I64, 'providerId', None, None, ), # 1
15245 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15246 
  )
15247 
 
3064 chandransh 15248 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15249 
    self.providerId = providerId
15250 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15251 
 
15252 
  def read(self, iprot):
15253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15255 
      return
15256 
    iprot.readStructBegin()
15257 
    while True:
15258 
      (fname, ftype, fid) = iprot.readFieldBegin()
15259 
      if ftype == TType.STOP:
15260 
        break
3064 chandransh 15261 
      if fid == 1:
1627 ankur.sing 15262 
        if ftype == TType.I64:
3064 chandransh 15263 
          self.providerId = iprot.readI64();
1627 ankur.sing 15264 
        else:
15265 
          iprot.skip(ftype)
3064 chandransh 15266 
      elif fid == 2:
15267 
        if ftype == TType.MAP:
15268 
          self.undeliveredOrders = {}
6188 rajveer 15269 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15270 
          for _i347 in xrange(_size343):
15271 
            _key348 = iprot.readString();
15272 
            _val349 = iprot.readString();
15273 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15274 
          iprot.readMapEnd()
15275 
        else:
15276 
          iprot.skip(ftype)
1627 ankur.sing 15277 
      else:
15278 
        iprot.skip(ftype)
15279 
      iprot.readFieldEnd()
15280 
    iprot.readStructEnd()
15281 
 
15282 
  def write(self, oprot):
15283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15285 
      return
3064 chandransh 15286 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15287 
    if self.providerId is not None:
3064 chandransh 15288 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15289 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15290 
      oprot.writeFieldEnd()
3431 rajveer 15291 
    if self.undeliveredOrders is not None:
3064 chandransh 15292 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15293 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15294 
      for kiter350,viter351 in self.undeliveredOrders.items():
15295 
        oprot.writeString(kiter350)
15296 
        oprot.writeString(viter351)
3064 chandransh 15297 
      oprot.writeMapEnd()
15298 
      oprot.writeFieldEnd()
1627 ankur.sing 15299 
    oprot.writeFieldStop()
15300 
    oprot.writeStructEnd()
15301 
 
3431 rajveer 15302 
  def validate(self):
15303 
    return
15304 
 
15305 
 
1627 ankur.sing 15306 
  def __repr__(self):
15307 
    L = ['%s=%r' % (key, value)
15308 
      for key, value in self.__dict__.iteritems()]
15309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15310 
 
15311 
  def __eq__(self, other):
15312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15313 
 
15314 
  def __ne__(self, other):
15315 
    return not (self == other)
15316 
 
3064 chandransh 15317 
class updateNonDeliveryReason_result:
1627 ankur.sing 15318 
  """
15319 
  Attributes:
3064 chandransh 15320 
   - ex
1627 ankur.sing 15321 
  """
15322 
 
15323 
  thrift_spec = (
4910 phani.kuma 15324 
    None, # 0
3064 chandransh 15325 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15326 
  )
15327 
 
4910 phani.kuma 15328 
  def __init__(self, ex=None,):
3064 chandransh 15329 
    self.ex = ex
1627 ankur.sing 15330 
 
15331 
  def read(self, iprot):
15332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15334 
      return
15335 
    iprot.readStructBegin()
15336 
    while True:
15337 
      (fname, ftype, fid) = iprot.readFieldBegin()
15338 
      if ftype == TType.STOP:
15339 
        break
4910 phani.kuma 15340 
      if fid == 1:
15341 
        if ftype == TType.STRUCT:
15342 
          self.ex = TransactionServiceException()
15343 
          self.ex.read(iprot)
15344 
        else:
15345 
          iprot.skip(ftype)
15346 
      else:
15347 
        iprot.skip(ftype)
15348 
      iprot.readFieldEnd()
15349 
    iprot.readStructEnd()
15350 
 
15351 
  def write(self, oprot):
15352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15354 
      return
15355 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15356 
    if self.ex is not None:
15357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15358 
      self.ex.write(oprot)
15359 
      oprot.writeFieldEnd()
15360 
    oprot.writeFieldStop()
15361 
    oprot.writeStructEnd()
15362 
 
15363 
  def validate(self):
15364 
    return
15365 
 
15366 
 
15367 
  def __repr__(self):
15368 
    L = ['%s=%r' % (key, value)
15369 
      for key, value in self.__dict__.iteritems()]
15370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15371 
 
15372 
  def __eq__(self, other):
15373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15374 
 
15375 
  def __ne__(self, other):
15376 
    return not (self == other)
15377 
 
15378 
class getNonDeliveredOrdersbyCourier_args:
15379 
  """
15380 
  Attributes:
15381 
   - providerId
15382 
  """
15383 
 
15384 
  thrift_spec = (
15385 
    None, # 0
15386 
    (1, TType.I64, 'providerId', None, None, ), # 1
15387 
  )
15388 
 
15389 
  def __init__(self, providerId=None,):
15390 
    self.providerId = providerId
15391 
 
15392 
  def read(self, iprot):
15393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15395 
      return
15396 
    iprot.readStructBegin()
15397 
    while True:
15398 
      (fname, ftype, fid) = iprot.readFieldBegin()
15399 
      if ftype == TType.STOP:
15400 
        break
15401 
      if fid == 1:
15402 
        if ftype == TType.I64:
15403 
          self.providerId = iprot.readI64();
15404 
        else:
15405 
          iprot.skip(ftype)
15406 
      else:
15407 
        iprot.skip(ftype)
15408 
      iprot.readFieldEnd()
15409 
    iprot.readStructEnd()
15410 
 
15411 
  def write(self, oprot):
15412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15414 
      return
15415 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15416 
    if self.providerId is not None:
15417 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15418 
      oprot.writeI64(self.providerId)
15419 
      oprot.writeFieldEnd()
15420 
    oprot.writeFieldStop()
15421 
    oprot.writeStructEnd()
15422 
 
15423 
  def validate(self):
15424 
    return
15425 
 
15426 
 
15427 
  def __repr__(self):
15428 
    L = ['%s=%r' % (key, value)
15429 
      for key, value in self.__dict__.iteritems()]
15430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15431 
 
15432 
  def __eq__(self, other):
15433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15434 
 
15435 
  def __ne__(self, other):
15436 
    return not (self == other)
15437 
 
15438 
class getNonDeliveredOrdersbyCourier_result:
15439 
  """
15440 
  Attributes:
15441 
   - success
15442 
  """
15443 
 
15444 
  thrift_spec = (
15445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15446 
  )
15447 
 
15448 
  def __init__(self, success=None,):
15449 
    self.success = success
15450 
 
15451 
  def read(self, iprot):
15452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15454 
      return
15455 
    iprot.readStructBegin()
15456 
    while True:
15457 
      (fname, ftype, fid) = iprot.readFieldBegin()
15458 
      if ftype == TType.STOP:
15459 
        break
4581 phani.kuma 15460 
      if fid == 0:
15461 
        if ftype == TType.LIST:
15462 
          self.success = []
6188 rajveer 15463 
          (_etype355, _size352) = iprot.readListBegin()
15464 
          for _i356 in xrange(_size352):
15465 
            _elem357 = Order()
15466 
            _elem357.read(iprot)
15467 
            self.success.append(_elem357)
4581 phani.kuma 15468 
          iprot.readListEnd()
15469 
        else:
15470 
          iprot.skip(ftype)
4910 phani.kuma 15471 
      else:
15472 
        iprot.skip(ftype)
15473 
      iprot.readFieldEnd()
15474 
    iprot.readStructEnd()
15475 
 
15476 
  def write(self, oprot):
15477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15479 
      return
15480 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15481 
    if self.success is not None:
15482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15484 
      for iter358 in self.success:
15485 
        iter358.write(oprot)
4910 phani.kuma 15486 
      oprot.writeListEnd()
15487 
      oprot.writeFieldEnd()
15488 
    oprot.writeFieldStop()
15489 
    oprot.writeStructEnd()
15490 
 
15491 
  def validate(self):
15492 
    return
15493 
 
15494 
 
15495 
  def __repr__(self):
15496 
    L = ['%s=%r' % (key, value)
15497 
      for key, value in self.__dict__.iteritems()]
15498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15499 
 
15500 
  def __eq__(self, other):
15501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15502 
 
15503 
  def __ne__(self, other):
15504 
    return not (self == other)
15505 
 
15506 
class markOrdersAsLocalConnected_args:
15507 
  """
15508 
  Attributes:
15509 
   - providerId
15510 
   - local_connected_orders
15511 
  """
15512 
 
15513 
  thrift_spec = (
15514 
    None, # 0
15515 
    (1, TType.I64, 'providerId', None, None, ), # 1
15516 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15517 
  )
15518 
 
15519 
  def __init__(self, providerId=None, local_connected_orders=None,):
15520 
    self.providerId = providerId
15521 
    self.local_connected_orders = local_connected_orders
15522 
 
15523 
  def read(self, iprot):
15524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15526 
      return
15527 
    iprot.readStructBegin()
15528 
    while True:
15529 
      (fname, ftype, fid) = iprot.readFieldBegin()
15530 
      if ftype == TType.STOP:
15531 
        break
15532 
      if fid == 1:
15533 
        if ftype == TType.I64:
15534 
          self.providerId = iprot.readI64();
15535 
        else:
15536 
          iprot.skip(ftype)
15537 
      elif fid == 2:
15538 
        if ftype == TType.MAP:
15539 
          self.local_connected_orders = {}
6188 rajveer 15540 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15541 
          for _i363 in xrange(_size359):
15542 
            _key364 = iprot.readString();
15543 
            _val365 = iprot.readString();
15544 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15545 
          iprot.readMapEnd()
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15558 
    if self.providerId is not None:
15559 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15560 
      oprot.writeI64(self.providerId)
15561 
      oprot.writeFieldEnd()
15562 
    if self.local_connected_orders is not None:
15563 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15564 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15565 
      for kiter366,viter367 in self.local_connected_orders.items():
15566 
        oprot.writeString(kiter366)
15567 
        oprot.writeString(viter367)
4910 phani.kuma 15568 
      oprot.writeMapEnd()
15569 
      oprot.writeFieldEnd()
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 markOrdersAsLocalConnected_result:
15589 
  """
15590 
  Attributes:
15591 
   - ex
15592 
  """
15593 
 
15594 
  thrift_spec = (
15595 
    None, # 0
15596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15597 
  )
15598 
 
15599 
  def __init__(self, ex=None,):
15600 
    self.ex = ex
15601 
 
15602 
  def read(self, iprot):
15603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15605 
      return
15606 
    iprot.readStructBegin()
15607 
    while True:
15608 
      (fname, ftype, fid) = iprot.readFieldBegin()
15609 
      if ftype == TType.STOP:
15610 
        break
15611 
      if fid == 1:
3064 chandransh 15612 
        if ftype == TType.STRUCT:
15613 
          self.ex = TransactionServiceException()
15614 
          self.ex.read(iprot)
1627 ankur.sing 15615 
        else:
15616 
          iprot.skip(ftype)
15617 
      else:
15618 
        iprot.skip(ftype)
15619 
      iprot.readFieldEnd()
15620 
    iprot.readStructEnd()
15621 
 
15622 
  def write(self, oprot):
15623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15625 
      return
4910 phani.kuma 15626 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15627 
    if self.ex is not None:
15628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15629 
      self.ex.write(oprot)
15630 
      oprot.writeFieldEnd()
15631 
    oprot.writeFieldStop()
15632 
    oprot.writeStructEnd()
15633 
 
15634 
  def validate(self):
15635 
    return
15636 
 
15637 
 
15638 
  def __repr__(self):
15639 
    L = ['%s=%r' % (key, value)
15640 
      for key, value in self.__dict__.iteritems()]
15641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15642 
 
15643 
  def __eq__(self, other):
15644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15645 
 
15646 
  def __ne__(self, other):
15647 
    return not (self == other)
15648 
 
15649 
class getOrdersNotLocalConnected_args:
15650 
  """
15651 
  Attributes:
15652 
   - providerId
15653 
  """
15654 
 
15655 
  thrift_spec = (
15656 
    None, # 0
15657 
    (1, TType.I64, 'providerId', None, None, ), # 1
15658 
  )
15659 
 
15660 
  def __init__(self, providerId=None,):
15661 
    self.providerId = providerId
15662 
 
15663 
  def read(self, iprot):
15664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15666 
      return
15667 
    iprot.readStructBegin()
15668 
    while True:
15669 
      (fname, ftype, fid) = iprot.readFieldBegin()
15670 
      if ftype == TType.STOP:
15671 
        break
15672 
      if fid == 1:
15673 
        if ftype == TType.I64:
15674 
          self.providerId = iprot.readI64();
15675 
        else:
15676 
          iprot.skip(ftype)
15677 
      else:
15678 
        iprot.skip(ftype)
15679 
      iprot.readFieldEnd()
15680 
    iprot.readStructEnd()
15681 
 
15682 
  def write(self, oprot):
15683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15685 
      return
15686 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15687 
    if self.providerId is not None:
15688 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15689 
      oprot.writeI64(self.providerId)
15690 
      oprot.writeFieldEnd()
15691 
    oprot.writeFieldStop()
15692 
    oprot.writeStructEnd()
15693 
 
15694 
  def validate(self):
15695 
    return
15696 
 
15697 
 
15698 
  def __repr__(self):
15699 
    L = ['%s=%r' % (key, value)
15700 
      for key, value in self.__dict__.iteritems()]
15701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15702 
 
15703 
  def __eq__(self, other):
15704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15705 
 
15706 
  def __ne__(self, other):
15707 
    return not (self == other)
15708 
 
15709 
class getOrdersNotLocalConnected_result:
15710 
  """
15711 
  Attributes:
15712 
   - success
15713 
  """
15714 
 
15715 
  thrift_spec = (
15716 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15717 
  )
15718 
 
15719 
  def __init__(self, success=None,):
15720 
    self.success = success
15721 
 
15722 
  def read(self, iprot):
15723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15725 
      return
15726 
    iprot.readStructBegin()
15727 
    while True:
15728 
      (fname, ftype, fid) = iprot.readFieldBegin()
15729 
      if ftype == TType.STOP:
15730 
        break
15731 
      if fid == 0:
15732 
        if ftype == TType.LIST:
15733 
          self.success = []
6188 rajveer 15734 
          (_etype371, _size368) = iprot.readListBegin()
15735 
          for _i372 in xrange(_size368):
15736 
            _elem373 = Order()
15737 
            _elem373.read(iprot)
15738 
            self.success.append(_elem373)
4910 phani.kuma 15739 
          iprot.readListEnd()
15740 
        else:
15741 
          iprot.skip(ftype)
15742 
      else:
15743 
        iprot.skip(ftype)
15744 
      iprot.readFieldEnd()
15745 
    iprot.readStructEnd()
15746 
 
15747 
  def write(self, oprot):
15748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15750 
      return
15751 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15752 
    if self.success is not None:
15753 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15754 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15755 
      for iter374 in self.success:
15756 
        iter374.write(oprot)
4581 phani.kuma 15757 
      oprot.writeListEnd()
15758 
      oprot.writeFieldEnd()
4910 phani.kuma 15759 
    oprot.writeFieldStop()
15760 
    oprot.writeStructEnd()
15761 
 
15762 
  def validate(self):
15763 
    return
15764 
 
15765 
 
15766 
  def __repr__(self):
15767 
    L = ['%s=%r' % (key, value)
15768 
      for key, value in self.__dict__.iteritems()]
15769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15770 
 
15771 
  def __eq__(self, other):
15772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15773 
 
15774 
  def __ne__(self, other):
15775 
    return not (self == other)
15776 
 
15777 
class markOrdersAsDestinationCityReached_args:
15778 
  """
15779 
  Attributes:
15780 
   - providerId
15781 
   - destination_city_reached_orders
15782 
  """
15783 
 
15784 
  thrift_spec = (
15785 
    None, # 0
15786 
    (1, TType.I64, 'providerId', None, None, ), # 1
15787 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15788 
  )
15789 
 
15790 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15791 
    self.providerId = providerId
15792 
    self.destination_city_reached_orders = destination_city_reached_orders
15793 
 
15794 
  def read(self, iprot):
15795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15797 
      return
15798 
    iprot.readStructBegin()
15799 
    while True:
15800 
      (fname, ftype, fid) = iprot.readFieldBegin()
15801 
      if ftype == TType.STOP:
15802 
        break
15803 
      if fid == 1:
15804 
        if ftype == TType.I64:
15805 
          self.providerId = iprot.readI64();
15806 
        else:
15807 
          iprot.skip(ftype)
15808 
      elif fid == 2:
15809 
        if ftype == TType.MAP:
15810 
          self.destination_city_reached_orders = {}
6188 rajveer 15811 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15812 
          for _i379 in xrange(_size375):
15813 
            _key380 = iprot.readString();
15814 
            _val381 = iprot.readString();
15815 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15816 
          iprot.readMapEnd()
15817 
        else:
15818 
          iprot.skip(ftype)
15819 
      else:
15820 
        iprot.skip(ftype)
15821 
      iprot.readFieldEnd()
15822 
    iprot.readStructEnd()
15823 
 
15824 
  def write(self, oprot):
15825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15827 
      return
15828 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15829 
    if self.providerId is not None:
15830 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15831 
      oprot.writeI64(self.providerId)
15832 
      oprot.writeFieldEnd()
15833 
    if self.destination_city_reached_orders is not None:
15834 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15835 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15836 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15837 
        oprot.writeString(kiter382)
15838 
        oprot.writeString(viter383)
4910 phani.kuma 15839 
      oprot.writeMapEnd()
15840 
      oprot.writeFieldEnd()
15841 
    oprot.writeFieldStop()
15842 
    oprot.writeStructEnd()
15843 
 
15844 
  def validate(self):
15845 
    return
15846 
 
15847 
 
15848 
  def __repr__(self):
15849 
    L = ['%s=%r' % (key, value)
15850 
      for key, value in self.__dict__.iteritems()]
15851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15852 
 
15853 
  def __eq__(self, other):
15854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15855 
 
15856 
  def __ne__(self, other):
15857 
    return not (self == other)
15858 
 
15859 
class markOrdersAsDestinationCityReached_result:
15860 
  """
15861 
  Attributes:
15862 
   - ex
15863 
  """
15864 
 
15865 
  thrift_spec = (
15866 
    None, # 0
15867 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15868 
  )
15869 
 
15870 
  def __init__(self, ex=None,):
15871 
    self.ex = ex
15872 
 
15873 
  def read(self, iprot):
15874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15876 
      return
15877 
    iprot.readStructBegin()
15878 
    while True:
15879 
      (fname, ftype, fid) = iprot.readFieldBegin()
15880 
      if ftype == TType.STOP:
15881 
        break
15882 
      if fid == 1:
15883 
        if ftype == TType.STRUCT:
15884 
          self.ex = TransactionServiceException()
15885 
          self.ex.read(iprot)
15886 
        else:
15887 
          iprot.skip(ftype)
15888 
      else:
15889 
        iprot.skip(ftype)
15890 
      iprot.readFieldEnd()
15891 
    iprot.readStructEnd()
15892 
 
15893 
  def write(self, oprot):
15894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15896 
      return
15897 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15898 
    if self.ex is not None:
3064 chandransh 15899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15900 
      self.ex.write(oprot)
1627 ankur.sing 15901 
      oprot.writeFieldEnd()
15902 
    oprot.writeFieldStop()
15903 
    oprot.writeStructEnd()
15904 
 
3431 rajveer 15905 
  def validate(self):
15906 
    return
15907 
 
15908 
 
1627 ankur.sing 15909 
  def __repr__(self):
15910 
    L = ['%s=%r' % (key, value)
15911 
      for key, value in self.__dict__.iteritems()]
15912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15913 
 
15914 
  def __eq__(self, other):
15915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15916 
 
15917 
  def __ne__(self, other):
15918 
    return not (self == other)
15919 
 
4910 phani.kuma 15920 
class markOrdersAsFirstDeliveryAttempted_args:
15921 
  """
15922 
  Attributes:
15923 
   - providerId
15924 
   - first_atdl_orders
15925 
  """
15926 
 
15927 
  thrift_spec = (
15928 
    None, # 0
15929 
    (1, TType.I64, 'providerId', None, None, ), # 1
15930 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15931 
  )
15932 
 
15933 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15934 
    self.providerId = providerId
15935 
    self.first_atdl_orders = first_atdl_orders
15936 
 
15937 
  def read(self, iprot):
15938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15940 
      return
15941 
    iprot.readStructBegin()
15942 
    while True:
15943 
      (fname, ftype, fid) = iprot.readFieldBegin()
15944 
      if ftype == TType.STOP:
15945 
        break
15946 
      if fid == 1:
15947 
        if ftype == TType.I64:
15948 
          self.providerId = iprot.readI64();
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      elif fid == 2:
15952 
        if ftype == TType.MAP:
15953 
          self.first_atdl_orders = {}
6188 rajveer 15954 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15955 
          for _i388 in xrange(_size384):
15956 
            _key389 = iprot.readString();
15957 
            _val390 = iprot.readString();
15958 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15959 
          iprot.readMapEnd()
15960 
        else:
15961 
          iprot.skip(ftype)
15962 
      else:
15963 
        iprot.skip(ftype)
15964 
      iprot.readFieldEnd()
15965 
    iprot.readStructEnd()
15966 
 
15967 
  def write(self, oprot):
15968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15970 
      return
15971 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15972 
    if self.providerId is not None:
15973 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15974 
      oprot.writeI64(self.providerId)
15975 
      oprot.writeFieldEnd()
15976 
    if self.first_atdl_orders is not None:
15977 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15978 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15979 
      for kiter391,viter392 in self.first_atdl_orders.items():
15980 
        oprot.writeString(kiter391)
15981 
        oprot.writeString(viter392)
4910 phani.kuma 15982 
      oprot.writeMapEnd()
15983 
      oprot.writeFieldEnd()
15984 
    oprot.writeFieldStop()
15985 
    oprot.writeStructEnd()
15986 
 
15987 
  def validate(self):
15988 
    return
15989 
 
15990 
 
15991 
  def __repr__(self):
15992 
    L = ['%s=%r' % (key, value)
15993 
      for key, value in self.__dict__.iteritems()]
15994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15995 
 
15996 
  def __eq__(self, other):
15997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15998 
 
15999 
  def __ne__(self, other):
16000 
    return not (self == other)
16001 
 
16002 
class markOrdersAsFirstDeliveryAttempted_result:
16003 
  """
16004 
  Attributes:
16005 
   - ex
16006 
  """
16007 
 
16008 
  thrift_spec = (
16009 
    None, # 0
16010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16011 
  )
16012 
 
16013 
  def __init__(self, ex=None,):
16014 
    self.ex = ex
16015 
 
16016 
  def read(self, iprot):
16017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16019 
      return
16020 
    iprot.readStructBegin()
16021 
    while True:
16022 
      (fname, ftype, fid) = iprot.readFieldBegin()
16023 
      if ftype == TType.STOP:
16024 
        break
16025 
      if fid == 1:
16026 
        if ftype == TType.STRUCT:
16027 
          self.ex = TransactionServiceException()
16028 
          self.ex.read(iprot)
16029 
        else:
16030 
          iprot.skip(ftype)
16031 
      else:
16032 
        iprot.skip(ftype)
16033 
      iprot.readFieldEnd()
16034 
    iprot.readStructEnd()
16035 
 
16036 
  def write(self, oprot):
16037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16039 
      return
16040 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16041 
    if self.ex is not None:
16042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16043 
      self.ex.write(oprot)
16044 
      oprot.writeFieldEnd()
16045 
    oprot.writeFieldStop()
16046 
    oprot.writeStructEnd()
16047 
 
16048 
  def validate(self):
16049 
    return
16050 
 
16051 
 
16052 
  def __repr__(self):
16053 
    L = ['%s=%r' % (key, value)
16054 
      for key, value in self.__dict__.iteritems()]
16055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16056 
 
16057 
  def __eq__(self, other):
16058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16059 
 
16060 
  def __ne__(self, other):
16061 
    return not (self == other)
16062 
 
3064 chandransh 16063 
class getUndeliveredOrders_args:
1886 ankur.sing 16064 
  """
16065 
  Attributes:
3064 chandransh 16066 
   - providerId
16067 
   - warehouseId
1886 ankur.sing 16068 
  """
1627 ankur.sing 16069 
 
1886 ankur.sing 16070 
  thrift_spec = (
16071 
    None, # 0
3064 chandransh 16072 
    (1, TType.I64, 'providerId', None, None, ), # 1
16073 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16074 
  )
16075 
 
3064 chandransh 16076 
  def __init__(self, providerId=None, warehouseId=None,):
16077 
    self.providerId = providerId
16078 
    self.warehouseId = warehouseId
1886 ankur.sing 16079 
 
16080 
  def read(self, iprot):
16081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16083 
      return
16084 
    iprot.readStructBegin()
16085 
    while True:
16086 
      (fname, ftype, fid) = iprot.readFieldBegin()
16087 
      if ftype == TType.STOP:
16088 
        break
16089 
      if fid == 1:
16090 
        if ftype == TType.I64:
3064 chandransh 16091 
          self.providerId = iprot.readI64();
1886 ankur.sing 16092 
        else:
16093 
          iprot.skip(ftype)
3064 chandransh 16094 
      elif fid == 2:
16095 
        if ftype == TType.I64:
16096 
          self.warehouseId = iprot.readI64();
16097 
        else:
16098 
          iprot.skip(ftype)
1886 ankur.sing 16099 
      else:
16100 
        iprot.skip(ftype)
16101 
      iprot.readFieldEnd()
16102 
    iprot.readStructEnd()
16103 
 
16104 
  def write(self, oprot):
16105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16107 
      return
3064 chandransh 16108 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16109 
    if self.providerId is not None:
3064 chandransh 16110 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16111 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16112 
      oprot.writeFieldEnd()
3431 rajveer 16113 
    if self.warehouseId is not None:
3064 chandransh 16114 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16115 
      oprot.writeI64(self.warehouseId)
16116 
      oprot.writeFieldEnd()
1886 ankur.sing 16117 
    oprot.writeFieldStop()
16118 
    oprot.writeStructEnd()
16119 
 
3431 rajveer 16120 
  def validate(self):
16121 
    return
16122 
 
16123 
 
1886 ankur.sing 16124 
  def __repr__(self):
16125 
    L = ['%s=%r' % (key, value)
16126 
      for key, value in self.__dict__.iteritems()]
16127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16128 
 
16129 
  def __eq__(self, other):
16130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16131 
 
16132 
  def __ne__(self, other):
16133 
    return not (self == other)
16134 
 
3064 chandransh 16135 
class getUndeliveredOrders_result:
1886 ankur.sing 16136 
  """
16137 
  Attributes:
16138 
   - success
16139 
  """
16140 
 
16141 
  thrift_spec = (
16142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16143 
  )
16144 
 
16145 
  def __init__(self, success=None,):
16146 
    self.success = success
16147 
 
16148 
  def read(self, iprot):
16149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16151 
      return
16152 
    iprot.readStructBegin()
16153 
    while True:
16154 
      (fname, ftype, fid) = iprot.readFieldBegin()
16155 
      if ftype == TType.STOP:
16156 
        break
16157 
      if fid == 0:
16158 
        if ftype == TType.LIST:
16159 
          self.success = []
6188 rajveer 16160 
          (_etype396, _size393) = iprot.readListBegin()
16161 
          for _i397 in xrange(_size393):
16162 
            _elem398 = Order()
16163 
            _elem398.read(iprot)
16164 
            self.success.append(_elem398)
1886 ankur.sing 16165 
          iprot.readListEnd()
16166 
        else:
16167 
          iprot.skip(ftype)
16168 
      else:
16169 
        iprot.skip(ftype)
16170 
      iprot.readFieldEnd()
16171 
    iprot.readStructEnd()
16172 
 
16173 
  def write(self, oprot):
16174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16176 
      return
3064 chandransh 16177 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16178 
    if self.success is not None:
1886 ankur.sing 16179 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16180 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16181 
      for iter399 in self.success:
16182 
        iter399.write(oprot)
1886 ankur.sing 16183 
      oprot.writeListEnd()
16184 
      oprot.writeFieldEnd()
16185 
    oprot.writeFieldStop()
16186 
    oprot.writeStructEnd()
16187 
 
3431 rajveer 16188 
  def validate(self):
16189 
    return
16190 
 
16191 
 
1886 ankur.sing 16192 
  def __repr__(self):
16193 
    L = ['%s=%r' % (key, value)
16194 
      for key, value in self.__dict__.iteritems()]
16195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16196 
 
16197 
  def __eq__(self, other):
16198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16199 
 
16200 
  def __ne__(self, other):
16201 
    return not (self == other)
16202 
 
4783 phani.kuma 16203 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16204 
 
16205 
  thrift_spec = (
16206 
  )
16207 
 
16208 
  def read(self, iprot):
16209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16211 
      return
16212 
    iprot.readStructBegin()
16213 
    while True:
16214 
      (fname, ftype, fid) = iprot.readFieldBegin()
16215 
      if ftype == TType.STOP:
16216 
        break
16217 
      else:
16218 
        iprot.skip(ftype)
16219 
      iprot.readFieldEnd()
16220 
    iprot.readStructEnd()
16221 
 
16222 
  def write(self, oprot):
16223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16225 
      return
16226 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16227 
    oprot.writeFieldStop()
16228 
    oprot.writeStructEnd()
16229 
 
16230 
  def validate(self):
16231 
    return
16232 
 
16233 
 
16234 
  def __repr__(self):
16235 
    L = ['%s=%r' % (key, value)
16236 
      for key, value in self.__dict__.iteritems()]
16237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16238 
 
16239 
  def __eq__(self, other):
16240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16241 
 
16242 
  def __ne__(self, other):
16243 
    return not (self == other)
16244 
 
16245 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16246 
  """
16247 
  Attributes:
16248 
   - success
16249 
  """
16250 
 
16251 
  thrift_spec = (
16252 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16253 
  )
16254 
 
16255 
  def __init__(self, success=None,):
16256 
    self.success = success
16257 
 
16258 
  def read(self, iprot):
16259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16261 
      return
16262 
    iprot.readStructBegin()
16263 
    while True:
16264 
      (fname, ftype, fid) = iprot.readFieldBegin()
16265 
      if ftype == TType.STOP:
16266 
        break
16267 
      if fid == 0:
16268 
        if ftype == TType.LIST:
16269 
          self.success = []
6188 rajveer 16270 
          (_etype403, _size400) = iprot.readListBegin()
16271 
          for _i404 in xrange(_size400):
16272 
            _elem405 = Order()
16273 
            _elem405.read(iprot)
16274 
            self.success.append(_elem405)
4783 phani.kuma 16275 
          iprot.readListEnd()
16276 
        else:
16277 
          iprot.skip(ftype)
16278 
      else:
16279 
        iprot.skip(ftype)
16280 
      iprot.readFieldEnd()
16281 
    iprot.readStructEnd()
16282 
 
16283 
  def write(self, oprot):
16284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16286 
      return
16287 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16288 
    if self.success is not None:
16289 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16290 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16291 
      for iter406 in self.success:
16292 
        iter406.write(oprot)
4783 phani.kuma 16293 
      oprot.writeListEnd()
16294 
      oprot.writeFieldEnd()
16295 
    oprot.writeFieldStop()
16296 
    oprot.writeStructEnd()
16297 
 
16298 
  def validate(self):
16299 
    return
16300 
 
16301 
 
16302 
  def __repr__(self):
16303 
    L = ['%s=%r' % (key, value)
16304 
      for key, value in self.__dict__.iteritems()]
16305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16306 
 
16307 
  def __eq__(self, other):
16308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16309 
 
16310 
  def __ne__(self, other):
16311 
    return not (self == other)
16312 
 
2536 chandransh 16313 
class toggleDOAFlag_args:
16314 
  """
16315 
  Attributes:
16316 
   - orderId
16317 
  """
1886 ankur.sing 16318 
 
2536 chandransh 16319 
  thrift_spec = (
16320 
    None, # 0
16321 
    (1, TType.I64, 'orderId', None, None, ), # 1
16322 
  )
16323 
 
16324 
  def __init__(self, orderId=None,):
16325 
    self.orderId = orderId
16326 
 
16327 
  def read(self, iprot):
16328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16330 
      return
16331 
    iprot.readStructBegin()
16332 
    while True:
16333 
      (fname, ftype, fid) = iprot.readFieldBegin()
16334 
      if ftype == TType.STOP:
16335 
        break
16336 
      if fid == 1:
16337 
        if ftype == TType.I64:
16338 
          self.orderId = iprot.readI64();
16339 
        else:
16340 
          iprot.skip(ftype)
16341 
      else:
16342 
        iprot.skip(ftype)
16343 
      iprot.readFieldEnd()
16344 
    iprot.readStructEnd()
16345 
 
16346 
  def write(self, oprot):
16347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16349 
      return
16350 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16351 
    if self.orderId is not None:
2536 chandransh 16352 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16353 
      oprot.writeI64(self.orderId)
16354 
      oprot.writeFieldEnd()
16355 
    oprot.writeFieldStop()
16356 
    oprot.writeStructEnd()
16357 
 
3431 rajveer 16358 
  def validate(self):
16359 
    return
16360 
 
16361 
 
2536 chandransh 16362 
  def __repr__(self):
16363 
    L = ['%s=%r' % (key, value)
16364 
      for key, value in self.__dict__.iteritems()]
16365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16366 
 
16367 
  def __eq__(self, other):
16368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16369 
 
16370 
  def __ne__(self, other):
16371 
    return not (self == other)
16372 
 
16373 
class toggleDOAFlag_result:
16374 
  """
16375 
  Attributes:
16376 
   - success
16377 
   - ex
16378 
  """
16379 
 
16380 
  thrift_spec = (
16381 
    (0, TType.BOOL, 'success', None, None, ), # 0
16382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16383 
  )
16384 
 
16385 
  def __init__(self, success=None, ex=None,):
16386 
    self.success = success
16387 
    self.ex = ex
16388 
 
16389 
  def read(self, iprot):
16390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16392 
      return
16393 
    iprot.readStructBegin()
16394 
    while True:
16395 
      (fname, ftype, fid) = iprot.readFieldBegin()
16396 
      if ftype == TType.STOP:
16397 
        break
16398 
      if fid == 0:
16399 
        if ftype == TType.BOOL:
16400 
          self.success = iprot.readBool();
16401 
        else:
16402 
          iprot.skip(ftype)
16403 
      elif fid == 1:
16404 
        if ftype == TType.STRUCT:
16405 
          self.ex = TransactionServiceException()
16406 
          self.ex.read(iprot)
16407 
        else:
16408 
          iprot.skip(ftype)
16409 
      else:
16410 
        iprot.skip(ftype)
16411 
      iprot.readFieldEnd()
16412 
    iprot.readStructEnd()
16413 
 
16414 
  def write(self, oprot):
16415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16417 
      return
16418 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16419 
    if self.success is not None:
2536 chandransh 16420 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16421 
      oprot.writeBool(self.success)
16422 
      oprot.writeFieldEnd()
3431 rajveer 16423 
    if self.ex is not None:
2536 chandransh 16424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16425 
      self.ex.write(oprot)
16426 
      oprot.writeFieldEnd()
16427 
    oprot.writeFieldStop()
16428 
    oprot.writeStructEnd()
16429 
 
3431 rajveer 16430 
  def validate(self):
16431 
    return
16432 
 
16433 
 
2536 chandransh 16434 
  def __repr__(self):
16435 
    L = ['%s=%r' % (key, value)
16436 
      for key, value in self.__dict__.iteritems()]
16437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16438 
 
16439 
  def __eq__(self, other):
16440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16441 
 
16442 
  def __ne__(self, other):
16443 
    return not (self == other)
16444 
 
4712 rajveer 16445 
class markOrderAsDelivered_args:
16446 
  """
16447 
  Attributes:
16448 
   - orderId
16449 
   - deliveryTimestamp
16450 
   - receiver
16451 
  """
16452 
 
16453 
  thrift_spec = None
16454 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16455 
    self.orderId = orderId
16456 
    self.deliveryTimestamp = deliveryTimestamp
16457 
    self.receiver = receiver
16458 
 
16459 
  def read(self, iprot):
16460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16462 
      return
16463 
    iprot.readStructBegin()
16464 
    while True:
16465 
      (fname, ftype, fid) = iprot.readFieldBegin()
16466 
      if ftype == TType.STOP:
16467 
        break
16468 
      if fid == 1:
16469 
        if ftype == TType.I64:
16470 
          self.orderId = iprot.readI64();
16471 
        else:
16472 
          iprot.skip(ftype)
16473 
      elif fid == 2:
16474 
        if ftype == TType.I64:
16475 
          self.deliveryTimestamp = iprot.readI64();
16476 
        else:
16477 
          iprot.skip(ftype)
16478 
      elif fid == -1:
16479 
        if ftype == TType.STRING:
16480 
          self.receiver = iprot.readString();
16481 
        else:
16482 
          iprot.skip(ftype)
16483 
      else:
16484 
        iprot.skip(ftype)
16485 
      iprot.readFieldEnd()
16486 
    iprot.readStructEnd()
16487 
 
16488 
  def write(self, oprot):
16489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16491 
      return
16492 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16493 
    if self.receiver is not None:
16494 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16495 
      oprot.writeString(self.receiver)
16496 
      oprot.writeFieldEnd()
16497 
    if self.orderId is not None:
16498 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16499 
      oprot.writeI64(self.orderId)
16500 
      oprot.writeFieldEnd()
16501 
    if self.deliveryTimestamp is not None:
16502 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16503 
      oprot.writeI64(self.deliveryTimestamp)
16504 
      oprot.writeFieldEnd()
16505 
    oprot.writeFieldStop()
16506 
    oprot.writeStructEnd()
16507 
 
16508 
  def validate(self):
16509 
    return
16510 
 
16511 
 
16512 
  def __repr__(self):
16513 
    L = ['%s=%r' % (key, value)
16514 
      for key, value in self.__dict__.iteritems()]
16515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16516 
 
16517 
  def __eq__(self, other):
16518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16519 
 
16520 
  def __ne__(self, other):
16521 
    return not (self == other)
16522 
 
16523 
class markOrderAsDelivered_result:
16524 
  """
16525 
  Attributes:
16526 
   - ex
16527 
  """
16528 
 
16529 
  thrift_spec = (
16530 
    None, # 0
16531 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16532 
  )
16533 
 
16534 
  def __init__(self, ex=None,):
16535 
    self.ex = ex
16536 
 
16537 
  def read(self, iprot):
16538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16540 
      return
16541 
    iprot.readStructBegin()
16542 
    while True:
16543 
      (fname, ftype, fid) = iprot.readFieldBegin()
16544 
      if ftype == TType.STOP:
16545 
        break
16546 
      if fid == 1:
16547 
        if ftype == TType.STRUCT:
16548 
          self.ex = TransactionServiceException()
16549 
          self.ex.read(iprot)
16550 
        else:
16551 
          iprot.skip(ftype)
16552 
      else:
16553 
        iprot.skip(ftype)
16554 
      iprot.readFieldEnd()
16555 
    iprot.readStructEnd()
16556 
 
16557 
  def write(self, oprot):
16558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16560 
      return
16561 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16562 
    if self.ex is not None:
16563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16564 
      self.ex.write(oprot)
16565 
      oprot.writeFieldEnd()
16566 
    oprot.writeFieldStop()
16567 
    oprot.writeStructEnd()
16568 
 
16569 
  def validate(self):
16570 
    return
16571 
 
16572 
 
16573 
  def __repr__(self):
16574 
    L = ['%s=%r' % (key, value)
16575 
      for key, value in self.__dict__.iteritems()]
16576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16577 
 
16578 
  def __eq__(self, other):
16579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16580 
 
16581 
  def __ne__(self, other):
16582 
    return not (self == other)
16583 
 
5553 rajveer 16584 
class markOrderAsReceivedAtStore_args:
16585 
  """
16586 
  Attributes:
16587 
   - orderId
16588 
   - deliveryTimestamp
16589 
  """
16590 
 
16591 
  thrift_spec = (
16592 
    None, # 0
16593 
    (1, TType.I64, 'orderId', None, None, ), # 1
16594 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16595 
  )
16596 
 
16597 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16598 
    self.orderId = orderId
16599 
    self.deliveryTimestamp = deliveryTimestamp
16600 
 
16601 
  def read(self, iprot):
16602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16604 
      return
16605 
    iprot.readStructBegin()
16606 
    while True:
16607 
      (fname, ftype, fid) = iprot.readFieldBegin()
16608 
      if ftype == TType.STOP:
16609 
        break
16610 
      if fid == 1:
16611 
        if ftype == TType.I64:
16612 
          self.orderId = iprot.readI64();
16613 
        else:
16614 
          iprot.skip(ftype)
16615 
      elif fid == 2:
16616 
        if ftype == TType.I64:
16617 
          self.deliveryTimestamp = iprot.readI64();
16618 
        else:
16619 
          iprot.skip(ftype)
16620 
      else:
16621 
        iprot.skip(ftype)
16622 
      iprot.readFieldEnd()
16623 
    iprot.readStructEnd()
16624 
 
16625 
  def write(self, oprot):
16626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16628 
      return
16629 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16630 
    if self.orderId is not None:
16631 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16632 
      oprot.writeI64(self.orderId)
16633 
      oprot.writeFieldEnd()
16634 
    if self.deliveryTimestamp is not None:
16635 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16636 
      oprot.writeI64(self.deliveryTimestamp)
16637 
      oprot.writeFieldEnd()
16638 
    oprot.writeFieldStop()
16639 
    oprot.writeStructEnd()
16640 
 
16641 
  def validate(self):
16642 
    return
16643 
 
16644 
 
16645 
  def __repr__(self):
16646 
    L = ['%s=%r' % (key, value)
16647 
      for key, value in self.__dict__.iteritems()]
16648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16649 
 
16650 
  def __eq__(self, other):
16651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16652 
 
16653 
  def __ne__(self, other):
16654 
    return not (self == other)
16655 
 
16656 
class markOrderAsReceivedAtStore_result:
16657 
  """
16658 
  Attributes:
16659 
   - ex
16660 
  """
16661 
 
16662 
  thrift_spec = (
16663 
    None, # 0
16664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16665 
  )
16666 
 
16667 
  def __init__(self, ex=None,):
16668 
    self.ex = ex
16669 
 
16670 
  def read(self, iprot):
16671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16673 
      return
16674 
    iprot.readStructBegin()
16675 
    while True:
16676 
      (fname, ftype, fid) = iprot.readFieldBegin()
16677 
      if ftype == TType.STOP:
16678 
        break
16679 
      if fid == 1:
16680 
        if ftype == TType.STRUCT:
16681 
          self.ex = TransactionServiceException()
16682 
          self.ex.read(iprot)
16683 
        else:
16684 
          iprot.skip(ftype)
16685 
      else:
16686 
        iprot.skip(ftype)
16687 
      iprot.readFieldEnd()
16688 
    iprot.readStructEnd()
16689 
 
16690 
  def write(self, oprot):
16691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16693 
      return
16694 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16695 
    if self.ex is not None:
16696 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16697 
      self.ex.write(oprot)
16698 
      oprot.writeFieldEnd()
16699 
    oprot.writeFieldStop()
16700 
    oprot.writeStructEnd()
16701 
 
16702 
  def validate(self):
16703 
    return
16704 
 
16705 
 
16706 
  def __repr__(self):
16707 
    L = ['%s=%r' % (key, value)
16708 
      for key, value in self.__dict__.iteritems()]
16709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16710 
 
16711 
  def __eq__(self, other):
16712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16713 
 
16714 
  def __ne__(self, other):
16715 
    return not (self == other)
16716 
 
4454 rajveer 16717 
class markOrderDoaRequestReceived_args:
16718 
  """
16719 
  Attributes:
16720 
   - orderId
16721 
  """
16722 
 
16723 
  thrift_spec = (
16724 
    None, # 0
16725 
    (1, TType.I64, 'orderId', None, None, ), # 1
16726 
  )
16727 
 
16728 
  def __init__(self, orderId=None,):
16729 
    self.orderId = orderId
16730 
 
16731 
  def read(self, iprot):
16732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16734 
      return
16735 
    iprot.readStructBegin()
16736 
    while True:
16737 
      (fname, ftype, fid) = iprot.readFieldBegin()
16738 
      if ftype == TType.STOP:
16739 
        break
16740 
      if fid == 1:
16741 
        if ftype == TType.I64:
16742 
          self.orderId = iprot.readI64();
16743 
        else:
16744 
          iprot.skip(ftype)
16745 
      else:
16746 
        iprot.skip(ftype)
16747 
      iprot.readFieldEnd()
16748 
    iprot.readStructEnd()
16749 
 
16750 
  def write(self, oprot):
16751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16753 
      return
16754 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16755 
    if self.orderId is not None:
16756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16757 
      oprot.writeI64(self.orderId)
16758 
      oprot.writeFieldEnd()
16759 
    oprot.writeFieldStop()
16760 
    oprot.writeStructEnd()
16761 
 
16762 
  def validate(self):
16763 
    return
16764 
 
16765 
 
16766 
  def __repr__(self):
16767 
    L = ['%s=%r' % (key, value)
16768 
      for key, value in self.__dict__.iteritems()]
16769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16770 
 
16771 
  def __eq__(self, other):
16772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16773 
 
16774 
  def __ne__(self, other):
16775 
    return not (self == other)
16776 
 
16777 
class markOrderDoaRequestReceived_result:
16778 
  """
16779 
  Attributes:
16780 
   - success
16781 
   - ex
16782 
  """
16783 
 
16784 
  thrift_spec = (
16785 
    (0, TType.BOOL, 'success', None, None, ), # 0
16786 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16787 
  )
16788 
 
16789 
  def __init__(self, success=None, ex=None,):
16790 
    self.success = success
16791 
    self.ex = ex
16792 
 
16793 
  def read(self, iprot):
16794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16796 
      return
16797 
    iprot.readStructBegin()
16798 
    while True:
16799 
      (fname, ftype, fid) = iprot.readFieldBegin()
16800 
      if ftype == TType.STOP:
16801 
        break
16802 
      if fid == 0:
16803 
        if ftype == TType.BOOL:
16804 
          self.success = iprot.readBool();
16805 
        else:
16806 
          iprot.skip(ftype)
16807 
      elif fid == 1:
16808 
        if ftype == TType.STRUCT:
16809 
          self.ex = TransactionServiceException()
16810 
          self.ex.read(iprot)
16811 
        else:
16812 
          iprot.skip(ftype)
16813 
      else:
16814 
        iprot.skip(ftype)
16815 
      iprot.readFieldEnd()
16816 
    iprot.readStructEnd()
16817 
 
16818 
  def write(self, oprot):
16819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16821 
      return
16822 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16823 
    if self.success is not None:
16824 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16825 
      oprot.writeBool(self.success)
16826 
      oprot.writeFieldEnd()
16827 
    if self.ex is not None:
16828 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16829 
      self.ex.write(oprot)
16830 
      oprot.writeFieldEnd()
16831 
    oprot.writeFieldStop()
16832 
    oprot.writeStructEnd()
16833 
 
16834 
  def validate(self):
16835 
    return
16836 
 
16837 
 
16838 
  def __repr__(self):
16839 
    L = ['%s=%r' % (key, value)
16840 
      for key, value in self.__dict__.iteritems()]
16841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16842 
 
16843 
  def __eq__(self, other):
16844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16845 
 
16846 
  def __ne__(self, other):
16847 
    return not (self == other)
16848 
 
16849 
class markOrderDoaRequestAuthorized_args:
16850 
  """
16851 
  Attributes:
16852 
   - orderId
16853 
   - isAuthorized
16854 
  """
16855 
 
16856 
  thrift_spec = (
16857 
    None, # 0
16858 
    (1, TType.I64, 'orderId', None, None, ), # 1
16859 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16860 
  )
16861 
 
16862 
  def __init__(self, orderId=None, isAuthorized=None,):
16863 
    self.orderId = orderId
16864 
    self.isAuthorized = isAuthorized
16865 
 
16866 
  def read(self, iprot):
16867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16869 
      return
16870 
    iprot.readStructBegin()
16871 
    while True:
16872 
      (fname, ftype, fid) = iprot.readFieldBegin()
16873 
      if ftype == TType.STOP:
16874 
        break
16875 
      if fid == 1:
16876 
        if ftype == TType.I64:
16877 
          self.orderId = iprot.readI64();
16878 
        else:
16879 
          iprot.skip(ftype)
16880 
      elif fid == 2:
16881 
        if ftype == TType.BOOL:
16882 
          self.isAuthorized = iprot.readBool();
16883 
        else:
16884 
          iprot.skip(ftype)
16885 
      else:
16886 
        iprot.skip(ftype)
16887 
      iprot.readFieldEnd()
16888 
    iprot.readStructEnd()
16889 
 
16890 
  def write(self, oprot):
16891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16893 
      return
16894 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16895 
    if self.orderId is not None:
16896 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16897 
      oprot.writeI64(self.orderId)
16898 
      oprot.writeFieldEnd()
16899 
    if self.isAuthorized is not None:
16900 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16901 
      oprot.writeBool(self.isAuthorized)
16902 
      oprot.writeFieldEnd()
16903 
    oprot.writeFieldStop()
16904 
    oprot.writeStructEnd()
16905 
 
16906 
  def validate(self):
16907 
    return
16908 
 
16909 
 
16910 
  def __repr__(self):
16911 
    L = ['%s=%r' % (key, value)
16912 
      for key, value in self.__dict__.iteritems()]
16913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16914 
 
16915 
  def __eq__(self, other):
16916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16917 
 
16918 
  def __ne__(self, other):
16919 
    return not (self == other)
16920 
 
16921 
class markOrderDoaRequestAuthorized_result:
16922 
  """
16923 
  Attributes:
16924 
   - success
16925 
   - ex
16926 
  """
16927 
 
16928 
  thrift_spec = (
16929 
    (0, TType.BOOL, 'success', None, None, ), # 0
16930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16931 
  )
16932 
 
16933 
  def __init__(self, success=None, ex=None,):
16934 
    self.success = success
16935 
    self.ex = ex
16936 
 
16937 
  def read(self, iprot):
16938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16940 
      return
16941 
    iprot.readStructBegin()
16942 
    while True:
16943 
      (fname, ftype, fid) = iprot.readFieldBegin()
16944 
      if ftype == TType.STOP:
16945 
        break
16946 
      if fid == 0:
16947 
        if ftype == TType.BOOL:
16948 
          self.success = iprot.readBool();
16949 
        else:
16950 
          iprot.skip(ftype)
16951 
      elif fid == 1:
16952 
        if ftype == TType.STRUCT:
16953 
          self.ex = TransactionServiceException()
16954 
          self.ex.read(iprot)
16955 
        else:
16956 
          iprot.skip(ftype)
16957 
      else:
16958 
        iprot.skip(ftype)
16959 
      iprot.readFieldEnd()
16960 
    iprot.readStructEnd()
16961 
 
16962 
  def write(self, oprot):
16963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16965 
      return
16966 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16967 
    if self.success is not None:
16968 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16969 
      oprot.writeBool(self.success)
16970 
      oprot.writeFieldEnd()
16971 
    if self.ex is not None:
16972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16973 
      self.ex.write(oprot)
16974 
      oprot.writeFieldEnd()
16975 
    oprot.writeFieldStop()
16976 
    oprot.writeStructEnd()
16977 
 
16978 
  def validate(self):
16979 
    return
16980 
 
16981 
 
16982 
  def __repr__(self):
16983 
    L = ['%s=%r' % (key, value)
16984 
      for key, value in self.__dict__.iteritems()]
16985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16986 
 
16987 
  def __eq__(self, other):
16988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16989 
 
16990 
  def __ne__(self, other):
16991 
    return not (self == other)
16992 
 
4488 rajveer 16993 
class markOrderReturnRequestReceived_args:
16994 
  """
16995 
  Attributes:
16996 
   - orderId
16997 
  """
16998 
 
16999 
  thrift_spec = (
17000 
    None, # 0
17001 
    (1, TType.I64, 'orderId', None, None, ), # 1
17002 
  )
17003 
 
17004 
  def __init__(self, orderId=None,):
17005 
    self.orderId = orderId
17006 
 
17007 
  def read(self, iprot):
17008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17010 
      return
17011 
    iprot.readStructBegin()
17012 
    while True:
17013 
      (fname, ftype, fid) = iprot.readFieldBegin()
17014 
      if ftype == TType.STOP:
17015 
        break
17016 
      if fid == 1:
17017 
        if ftype == TType.I64:
17018 
          self.orderId = iprot.readI64();
17019 
        else:
17020 
          iprot.skip(ftype)
17021 
      else:
17022 
        iprot.skip(ftype)
17023 
      iprot.readFieldEnd()
17024 
    iprot.readStructEnd()
17025 
 
17026 
  def write(self, oprot):
17027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17029 
      return
17030 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17031 
    if self.orderId is not None:
17032 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17033 
      oprot.writeI64(self.orderId)
17034 
      oprot.writeFieldEnd()
17035 
    oprot.writeFieldStop()
17036 
    oprot.writeStructEnd()
17037 
 
17038 
  def validate(self):
17039 
    return
17040 
 
17041 
 
17042 
  def __repr__(self):
17043 
    L = ['%s=%r' % (key, value)
17044 
      for key, value in self.__dict__.iteritems()]
17045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17046 
 
17047 
  def __eq__(self, other):
17048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17049 
 
17050 
  def __ne__(self, other):
17051 
    return not (self == other)
17052 
 
17053 
class markOrderReturnRequestReceived_result:
17054 
  """
17055 
  Attributes:
17056 
   - success
17057 
   - ex
17058 
  """
17059 
 
17060 
  thrift_spec = (
17061 
    (0, TType.BOOL, 'success', None, None, ), # 0
17062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17063 
  )
17064 
 
17065 
  def __init__(self, success=None, ex=None,):
17066 
    self.success = success
17067 
    self.ex = ex
17068 
 
17069 
  def read(self, iprot):
17070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17072 
      return
17073 
    iprot.readStructBegin()
17074 
    while True:
17075 
      (fname, ftype, fid) = iprot.readFieldBegin()
17076 
      if ftype == TType.STOP:
17077 
        break
17078 
      if fid == 0:
17079 
        if ftype == TType.BOOL:
17080 
          self.success = iprot.readBool();
17081 
        else:
17082 
          iprot.skip(ftype)
17083 
      elif fid == 1:
17084 
        if ftype == TType.STRUCT:
17085 
          self.ex = TransactionServiceException()
17086 
          self.ex.read(iprot)
17087 
        else:
17088 
          iprot.skip(ftype)
17089 
      else:
17090 
        iprot.skip(ftype)
17091 
      iprot.readFieldEnd()
17092 
    iprot.readStructEnd()
17093 
 
17094 
  def write(self, oprot):
17095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17097 
      return
17098 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17099 
    if self.success is not None:
17100 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17101 
      oprot.writeBool(self.success)
17102 
      oprot.writeFieldEnd()
17103 
    if self.ex is not None:
17104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17105 
      self.ex.write(oprot)
17106 
      oprot.writeFieldEnd()
17107 
    oprot.writeFieldStop()
17108 
    oprot.writeStructEnd()
17109 
 
17110 
  def validate(self):
17111 
    return
17112 
 
17113 
 
17114 
  def __repr__(self):
17115 
    L = ['%s=%r' % (key, value)
17116 
      for key, value in self.__dict__.iteritems()]
17117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17118 
 
17119 
  def __eq__(self, other):
17120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17121 
 
17122 
  def __ne__(self, other):
17123 
    return not (self == other)
17124 
 
17125 
class markOrderReturnRequestAuthorized_args:
17126 
  """
17127 
  Attributes:
17128 
   - orderId
17129 
   - isAuthorized
17130 
  """
17131 
 
17132 
  thrift_spec = (
17133 
    None, # 0
17134 
    (1, TType.I64, 'orderId', None, None, ), # 1
17135 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17136 
  )
17137 
 
17138 
  def __init__(self, orderId=None, isAuthorized=None,):
17139 
    self.orderId = orderId
17140 
    self.isAuthorized = isAuthorized
17141 
 
17142 
  def read(self, iprot):
17143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17145 
      return
17146 
    iprot.readStructBegin()
17147 
    while True:
17148 
      (fname, ftype, fid) = iprot.readFieldBegin()
17149 
      if ftype == TType.STOP:
17150 
        break
17151 
      if fid == 1:
17152 
        if ftype == TType.I64:
17153 
          self.orderId = iprot.readI64();
17154 
        else:
17155 
          iprot.skip(ftype)
17156 
      elif fid == 2:
17157 
        if ftype == TType.BOOL:
17158 
          self.isAuthorized = iprot.readBool();
17159 
        else:
17160 
          iprot.skip(ftype)
17161 
      else:
17162 
        iprot.skip(ftype)
17163 
      iprot.readFieldEnd()
17164 
    iprot.readStructEnd()
17165 
 
17166 
  def write(self, oprot):
17167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17169 
      return
17170 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17171 
    if self.orderId is not None:
17172 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17173 
      oprot.writeI64(self.orderId)
17174 
      oprot.writeFieldEnd()
17175 
    if self.isAuthorized is not None:
17176 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17177 
      oprot.writeBool(self.isAuthorized)
17178 
      oprot.writeFieldEnd()
17179 
    oprot.writeFieldStop()
17180 
    oprot.writeStructEnd()
17181 
 
17182 
  def validate(self):
17183 
    return
17184 
 
17185 
 
17186 
  def __repr__(self):
17187 
    L = ['%s=%r' % (key, value)
17188 
      for key, value in self.__dict__.iteritems()]
17189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17190 
 
17191 
  def __eq__(self, other):
17192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17193 
 
17194 
  def __ne__(self, other):
17195 
    return not (self == other)
17196 
 
17197 
class markOrderReturnRequestAuthorized_result:
17198 
  """
17199 
  Attributes:
17200 
   - success
17201 
   - ex
17202 
  """
17203 
 
17204 
  thrift_spec = (
17205 
    (0, TType.BOOL, 'success', None, None, ), # 0
17206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17207 
  )
17208 
 
17209 
  def __init__(self, success=None, ex=None,):
17210 
    self.success = success
17211 
    self.ex = ex
17212 
 
17213 
  def read(self, iprot):
17214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17216 
      return
17217 
    iprot.readStructBegin()
17218 
    while True:
17219 
      (fname, ftype, fid) = iprot.readFieldBegin()
17220 
      if ftype == TType.STOP:
17221 
        break
17222 
      if fid == 0:
17223 
        if ftype == TType.BOOL:
17224 
          self.success = iprot.readBool();
17225 
        else:
17226 
          iprot.skip(ftype)
17227 
      elif fid == 1:
17228 
        if ftype == TType.STRUCT:
17229 
          self.ex = TransactionServiceException()
17230 
          self.ex.read(iprot)
17231 
        else:
17232 
          iprot.skip(ftype)
17233 
      else:
17234 
        iprot.skip(ftype)
17235 
      iprot.readFieldEnd()
17236 
    iprot.readStructEnd()
17237 
 
17238 
  def write(self, oprot):
17239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17241 
      return
17242 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17243 
    if self.success is not None:
17244 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17245 
      oprot.writeBool(self.success)
17246 
      oprot.writeFieldEnd()
17247 
    if self.ex is not None:
17248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17249 
      self.ex.write(oprot)
17250 
      oprot.writeFieldEnd()
17251 
    oprot.writeFieldStop()
17252 
    oprot.writeStructEnd()
17253 
 
17254 
  def validate(self):
17255 
    return
17256 
 
17257 
 
17258 
  def __repr__(self):
17259 
    L = ['%s=%r' % (key, value)
17260 
      for key, value in self.__dict__.iteritems()]
17261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17262 
 
17263 
  def __eq__(self, other):
17264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17265 
 
17266 
  def __ne__(self, other):
17267 
    return not (self == other)
17268 
 
2536 chandransh 17269 
class requestPickupNumber_args:
17270 
  """
17271 
  Attributes:
17272 
   - orderId
4579 rajveer 17273 
   - providerId
2536 chandransh 17274 
  """
17275 
 
17276 
  thrift_spec = (
17277 
    None, # 0
17278 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17279 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17280 
  )
17281 
 
4579 rajveer 17282 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17283 
    self.orderId = orderId
4579 rajveer 17284 
    self.providerId = providerId
2536 chandransh 17285 
 
17286 
  def read(self, iprot):
17287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17289 
      return
17290 
    iprot.readStructBegin()
17291 
    while True:
17292 
      (fname, ftype, fid) = iprot.readFieldBegin()
17293 
      if ftype == TType.STOP:
17294 
        break
17295 
      if fid == 1:
17296 
        if ftype == TType.I64:
17297 
          self.orderId = iprot.readI64();
17298 
        else:
17299 
          iprot.skip(ftype)
4579 rajveer 17300 
      elif fid == 2:
17301 
        if ftype == TType.I64:
17302 
          self.providerId = iprot.readI64();
17303 
        else:
17304 
          iprot.skip(ftype)
2536 chandransh 17305 
      else:
17306 
        iprot.skip(ftype)
17307 
      iprot.readFieldEnd()
17308 
    iprot.readStructEnd()
17309 
 
17310 
  def write(self, oprot):
17311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17313 
      return
17314 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17315 
    if self.orderId is not None:
2536 chandransh 17316 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17317 
      oprot.writeI64(self.orderId)
17318 
      oprot.writeFieldEnd()
4579 rajveer 17319 
    if self.providerId is not None:
17320 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17321 
      oprot.writeI64(self.providerId)
17322 
      oprot.writeFieldEnd()
2536 chandransh 17323 
    oprot.writeFieldStop()
17324 
    oprot.writeStructEnd()
17325 
 
3431 rajveer 17326 
  def validate(self):
17327 
    return
17328 
 
17329 
 
2536 chandransh 17330 
  def __repr__(self):
17331 
    L = ['%s=%r' % (key, value)
17332 
      for key, value in self.__dict__.iteritems()]
17333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17334 
 
17335 
  def __eq__(self, other):
17336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17337 
 
17338 
  def __ne__(self, other):
17339 
    return not (self == other)
17340 
 
17341 
class requestPickupNumber_result:
17342 
  """
17343 
  Attributes:
17344 
   - success
17345 
   - ex
17346 
  """
17347 
 
17348 
  thrift_spec = (
17349 
    (0, TType.BOOL, 'success', None, None, ), # 0
17350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17351 
  )
17352 
 
17353 
  def __init__(self, success=None, ex=None,):
17354 
    self.success = success
17355 
    self.ex = ex
17356 
 
17357 
  def read(self, iprot):
17358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17360 
      return
17361 
    iprot.readStructBegin()
17362 
    while True:
17363 
      (fname, ftype, fid) = iprot.readFieldBegin()
17364 
      if ftype == TType.STOP:
17365 
        break
17366 
      if fid == 0:
17367 
        if ftype == TType.BOOL:
17368 
          self.success = iprot.readBool();
17369 
        else:
17370 
          iprot.skip(ftype)
17371 
      elif fid == 1:
17372 
        if ftype == TType.STRUCT:
17373 
          self.ex = TransactionServiceException()
17374 
          self.ex.read(iprot)
17375 
        else:
17376 
          iprot.skip(ftype)
17377 
      else:
17378 
        iprot.skip(ftype)
17379 
      iprot.readFieldEnd()
17380 
    iprot.readStructEnd()
17381 
 
17382 
  def write(self, oprot):
17383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17385 
      return
17386 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17387 
    if self.success is not None:
2536 chandransh 17388 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17389 
      oprot.writeBool(self.success)
17390 
      oprot.writeFieldEnd()
3431 rajveer 17391 
    if self.ex is not None:
2536 chandransh 17392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17393 
      self.ex.write(oprot)
17394 
      oprot.writeFieldEnd()
17395 
    oprot.writeFieldStop()
17396 
    oprot.writeStructEnd()
17397 
 
3431 rajveer 17398 
  def validate(self):
17399 
    return
17400 
 
17401 
 
2536 chandransh 17402 
  def __repr__(self):
17403 
    L = ['%s=%r' % (key, value)
17404 
      for key, value in self.__dict__.iteritems()]
17405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17406 
 
17407 
  def __eq__(self, other):
17408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17409 
 
17410 
  def __ne__(self, other):
17411 
    return not (self == other)
17412 
 
17413 
class authorizePickup_args:
17414 
  """
17415 
  Attributes:
17416 
   - orderId
17417 
   - pickupNumber
4602 rajveer 17418 
   - providerId
2536 chandransh 17419 
  """
17420 
 
17421 
  thrift_spec = (
17422 
    None, # 0
17423 
    (1, TType.I64, 'orderId', None, None, ), # 1
17424 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17425 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17426 
  )
17427 
 
4602 rajveer 17428 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17429 
    self.orderId = orderId
17430 
    self.pickupNumber = pickupNumber
4602 rajveer 17431 
    self.providerId = providerId
2536 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)
17447 
      elif fid == 2:
17448 
        if ftype == TType.STRING:
17449 
          self.pickupNumber = iprot.readString();
17450 
        else:
17451 
          iprot.skip(ftype)
4602 rajveer 17452 
      elif fid == 3:
17453 
        if ftype == TType.I64:
17454 
          self.providerId = iprot.readI64();
17455 
        else:
17456 
          iprot.skip(ftype)
2536 chandransh 17457 
      else:
17458 
        iprot.skip(ftype)
17459 
      iprot.readFieldEnd()
17460 
    iprot.readStructEnd()
17461 
 
17462 
  def write(self, oprot):
17463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17465 
      return
17466 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17467 
    if self.orderId is not None:
2536 chandransh 17468 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17469 
      oprot.writeI64(self.orderId)
17470 
      oprot.writeFieldEnd()
3431 rajveer 17471 
    if self.pickupNumber is not None:
2536 chandransh 17472 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17473 
      oprot.writeString(self.pickupNumber)
17474 
      oprot.writeFieldEnd()
4602 rajveer 17475 
    if self.providerId is not None:
17476 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17477 
      oprot.writeI64(self.providerId)
17478 
      oprot.writeFieldEnd()
2536 chandransh 17479 
    oprot.writeFieldStop()
17480 
    oprot.writeStructEnd()
17481 
 
3431 rajveer 17482 
  def validate(self):
17483 
    return
17484 
 
17485 
 
2536 chandransh 17486 
  def __repr__(self):
17487 
    L = ['%s=%r' % (key, value)
17488 
      for key, value in self.__dict__.iteritems()]
17489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17490 
 
17491 
  def __eq__(self, other):
17492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17493 
 
17494 
  def __ne__(self, other):
17495 
    return not (self == other)
17496 
 
17497 
class authorizePickup_result:
17498 
  """
17499 
  Attributes:
17500 
   - success
17501 
   - ex
17502 
  """
17503 
 
17504 
  thrift_spec = (
17505 
    (0, TType.BOOL, 'success', None, None, ), # 0
17506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17507 
  )
17508 
 
17509 
  def __init__(self, success=None, ex=None,):
17510 
    self.success = success
17511 
    self.ex = ex
17512 
 
17513 
  def read(self, iprot):
17514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17516 
      return
17517 
    iprot.readStructBegin()
17518 
    while True:
17519 
      (fname, ftype, fid) = iprot.readFieldBegin()
17520 
      if ftype == TType.STOP:
17521 
        break
17522 
      if fid == 0:
17523 
        if ftype == TType.BOOL:
17524 
          self.success = iprot.readBool();
17525 
        else:
17526 
          iprot.skip(ftype)
17527 
      elif fid == 1:
17528 
        if ftype == TType.STRUCT:
17529 
          self.ex = TransactionServiceException()
17530 
          self.ex.read(iprot)
17531 
        else:
17532 
          iprot.skip(ftype)
17533 
      else:
17534 
        iprot.skip(ftype)
17535 
      iprot.readFieldEnd()
17536 
    iprot.readStructEnd()
17537 
 
17538 
  def write(self, oprot):
17539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17541 
      return
17542 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17543 
    if self.success is not None:
2536 chandransh 17544 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17545 
      oprot.writeBool(self.success)
17546 
      oprot.writeFieldEnd()
3431 rajveer 17547 
    if self.ex is not None:
2536 chandransh 17548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17549 
      self.ex.write(oprot)
17550 
      oprot.writeFieldEnd()
17551 
    oprot.writeFieldStop()
17552 
    oprot.writeStructEnd()
17553 
 
3431 rajveer 17554 
  def validate(self):
17555 
    return
17556 
 
17557 
 
2536 chandransh 17558 
  def __repr__(self):
17559 
    L = ['%s=%r' % (key, value)
17560 
      for key, value in self.__dict__.iteritems()]
17561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17562 
 
17563 
  def __eq__(self, other):
17564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17565 
 
17566 
  def __ne__(self, other):
17567 
    return not (self == other)
17568 
 
2764 chandransh 17569 
class markDoasAsPickedUp_args:
17570 
  """
17571 
  Attributes:
17572 
   - providerId
17573 
   - pickupDetails
17574 
  """
17575 
 
17576 
  thrift_spec = (
17577 
    None, # 0
17578 
    (1, TType.I64, 'providerId', None, None, ), # 1
17579 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17580 
  )
17581 
 
17582 
  def __init__(self, providerId=None, pickupDetails=None,):
17583 
    self.providerId = providerId
17584 
    self.pickupDetails = pickupDetails
17585 
 
17586 
  def read(self, iprot):
17587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17589 
      return
17590 
    iprot.readStructBegin()
17591 
    while True:
17592 
      (fname, ftype, fid) = iprot.readFieldBegin()
17593 
      if ftype == TType.STOP:
17594 
        break
17595 
      if fid == 1:
17596 
        if ftype == TType.I64:
17597 
          self.providerId = iprot.readI64();
17598 
        else:
17599 
          iprot.skip(ftype)
17600 
      elif fid == 2:
17601 
        if ftype == TType.MAP:
17602 
          self.pickupDetails = {}
6188 rajveer 17603 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17604 
          for _i411 in xrange(_size407):
17605 
            _key412 = iprot.readString();
17606 
            _val413 = iprot.readString();
17607 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17608 
          iprot.readMapEnd()
17609 
        else:
17610 
          iprot.skip(ftype)
17611 
      else:
17612 
        iprot.skip(ftype)
17613 
      iprot.readFieldEnd()
17614 
    iprot.readStructEnd()
17615 
 
17616 
  def write(self, oprot):
17617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17619 
      return
17620 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17621 
    if self.providerId is not None:
2764 chandransh 17622 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17623 
      oprot.writeI64(self.providerId)
17624 
      oprot.writeFieldEnd()
3431 rajveer 17625 
    if self.pickupDetails is not None:
2764 chandransh 17626 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17627 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17628 
      for kiter414,viter415 in self.pickupDetails.items():
17629 
        oprot.writeString(kiter414)
17630 
        oprot.writeString(viter415)
2764 chandransh 17631 
      oprot.writeMapEnd()
17632 
      oprot.writeFieldEnd()
17633 
    oprot.writeFieldStop()
17634 
    oprot.writeStructEnd()
17635 
 
3431 rajveer 17636 
  def validate(self):
17637 
    return
17638 
 
17639 
 
2764 chandransh 17640 
  def __repr__(self):
17641 
    L = ['%s=%r' % (key, value)
17642 
      for key, value in self.__dict__.iteritems()]
17643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17644 
 
17645 
  def __eq__(self, other):
17646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17647 
 
17648 
  def __ne__(self, other):
17649 
    return not (self == other)
17650 
 
17651 
class markDoasAsPickedUp_result:
4910 phani.kuma 17652 
 
17653 
  thrift_spec = (
17654 
  )
17655 
 
17656 
  def read(self, iprot):
17657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17659 
      return
17660 
    iprot.readStructBegin()
17661 
    while True:
17662 
      (fname, ftype, fid) = iprot.readFieldBegin()
17663 
      if ftype == TType.STOP:
17664 
        break
17665 
      else:
17666 
        iprot.skip(ftype)
17667 
      iprot.readFieldEnd()
17668 
    iprot.readStructEnd()
17669 
 
17670 
  def write(self, oprot):
17671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17673 
      return
17674 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17675 
    oprot.writeFieldStop()
17676 
    oprot.writeStructEnd()
17677 
 
17678 
  def validate(self):
17679 
    return
17680 
 
17681 
 
17682 
  def __repr__(self):
17683 
    L = ['%s=%r' % (key, value)
17684 
      for key, value in self.__dict__.iteritems()]
17685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17686 
 
17687 
  def __eq__(self, other):
17688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17689 
 
17690 
  def __ne__(self, other):
17691 
    return not (self == other)
17692 
 
17693 
class getDoasNotPickedUp_args:
2764 chandransh 17694 
  """
17695 
  Attributes:
4910 phani.kuma 17696 
   - providerId
17697 
  """
17698 
 
17699 
  thrift_spec = (
17700 
    None, # 0
17701 
    (1, TType.I64, 'providerId', None, None, ), # 1
17702 
  )
17703 
 
17704 
  def __init__(self, providerId=None,):
17705 
    self.providerId = providerId
17706 
 
17707 
  def read(self, iprot):
17708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17710 
      return
17711 
    iprot.readStructBegin()
17712 
    while True:
17713 
      (fname, ftype, fid) = iprot.readFieldBegin()
17714 
      if ftype == TType.STOP:
17715 
        break
17716 
      if fid == 1:
17717 
        if ftype == TType.I64:
17718 
          self.providerId = iprot.readI64();
17719 
        else:
17720 
          iprot.skip(ftype)
17721 
      else:
17722 
        iprot.skip(ftype)
17723 
      iprot.readFieldEnd()
17724 
    iprot.readStructEnd()
17725 
 
17726 
  def write(self, oprot):
17727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17729 
      return
17730 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17731 
    if self.providerId is not None:
17732 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17733 
      oprot.writeI64(self.providerId)
17734 
      oprot.writeFieldEnd()
17735 
    oprot.writeFieldStop()
17736 
    oprot.writeStructEnd()
17737 
 
17738 
  def validate(self):
17739 
    return
17740 
 
17741 
 
17742 
  def __repr__(self):
17743 
    L = ['%s=%r' % (key, value)
17744 
      for key, value in self.__dict__.iteritems()]
17745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17746 
 
17747 
  def __eq__(self, other):
17748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17749 
 
17750 
  def __ne__(self, other):
17751 
    return not (self == other)
17752 
 
17753 
class getDoasNotPickedUp_result:
17754 
  """
17755 
  Attributes:
2764 chandransh 17756 
   - success
17757 
  """
17758 
 
17759 
  thrift_spec = (
17760 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17761 
  )
17762 
 
17763 
  def __init__(self, success=None,):
17764 
    self.success = success
17765 
 
17766 
  def read(self, iprot):
17767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17769 
      return
17770 
    iprot.readStructBegin()
17771 
    while True:
17772 
      (fname, ftype, fid) = iprot.readFieldBegin()
17773 
      if ftype == TType.STOP:
17774 
        break
17775 
      if fid == 0:
17776 
        if ftype == TType.LIST:
17777 
          self.success = []
6188 rajveer 17778 
          (_etype419, _size416) = iprot.readListBegin()
17779 
          for _i420 in xrange(_size416):
17780 
            _elem421 = Order()
17781 
            _elem421.read(iprot)
17782 
            self.success.append(_elem421)
2764 chandransh 17783 
          iprot.readListEnd()
17784 
        else:
17785 
          iprot.skip(ftype)
17786 
      else:
17787 
        iprot.skip(ftype)
17788 
      iprot.readFieldEnd()
17789 
    iprot.readStructEnd()
17790 
 
17791 
  def write(self, oprot):
17792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17794 
      return
4910 phani.kuma 17795 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17796 
    if self.success is not None:
2764 chandransh 17797 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17798 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17799 
      for iter422 in self.success:
17800 
        iter422.write(oprot)
2764 chandransh 17801 
      oprot.writeListEnd()
17802 
      oprot.writeFieldEnd()
17803 
    oprot.writeFieldStop()
17804 
    oprot.writeStructEnd()
17805 
 
3431 rajveer 17806 
  def validate(self):
17807 
    return
17808 
 
17809 
 
2764 chandransh 17810 
  def __repr__(self):
17811 
    L = ['%s=%r' % (key, value)
17812 
      for key, value in self.__dict__.iteritems()]
17813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17814 
 
17815 
  def __eq__(self, other):
17816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17817 
 
17818 
  def __ne__(self, other):
17819 
    return not (self == other)
17820 
 
4741 phani.kuma 17821 
class markReturnOrdersAsPickedUp_args:
17822 
  """
17823 
  Attributes:
17824 
   - providerId
17825 
   - pickupDetails
17826 
  """
17827 
 
17828 
  thrift_spec = (
17829 
    None, # 0
17830 
    (1, TType.I64, 'providerId', None, None, ), # 1
17831 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17832 
  )
17833 
 
17834 
  def __init__(self, providerId=None, pickupDetails=None,):
17835 
    self.providerId = providerId
17836 
    self.pickupDetails = pickupDetails
17837 
 
17838 
  def read(self, iprot):
17839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17841 
      return
17842 
    iprot.readStructBegin()
17843 
    while True:
17844 
      (fname, ftype, fid) = iprot.readFieldBegin()
17845 
      if ftype == TType.STOP:
17846 
        break
17847 
      if fid == 1:
17848 
        if ftype == TType.I64:
17849 
          self.providerId = iprot.readI64();
17850 
        else:
17851 
          iprot.skip(ftype)
17852 
      elif fid == 2:
17853 
        if ftype == TType.MAP:
17854 
          self.pickupDetails = {}
6188 rajveer 17855 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17856 
          for _i427 in xrange(_size423):
17857 
            _key428 = iprot.readString();
17858 
            _val429 = iprot.readString();
17859 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17860 
          iprot.readMapEnd()
17861 
        else:
17862 
          iprot.skip(ftype)
17863 
      else:
17864 
        iprot.skip(ftype)
17865 
      iprot.readFieldEnd()
17866 
    iprot.readStructEnd()
17867 
 
17868 
  def write(self, oprot):
17869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17871 
      return
17872 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17873 
    if self.providerId is not None:
17874 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17875 
      oprot.writeI64(self.providerId)
17876 
      oprot.writeFieldEnd()
17877 
    if self.pickupDetails is not None:
17878 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17879 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17880 
      for kiter430,viter431 in self.pickupDetails.items():
17881 
        oprot.writeString(kiter430)
17882 
        oprot.writeString(viter431)
4741 phani.kuma 17883 
      oprot.writeMapEnd()
17884 
      oprot.writeFieldEnd()
17885 
    oprot.writeFieldStop()
17886 
    oprot.writeStructEnd()
17887 
 
17888 
  def validate(self):
17889 
    return
17890 
 
17891 
 
17892 
  def __repr__(self):
17893 
    L = ['%s=%r' % (key, value)
17894 
      for key, value in self.__dict__.iteritems()]
17895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17896 
 
17897 
  def __eq__(self, other):
17898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17899 
 
17900 
  def __ne__(self, other):
17901 
    return not (self == other)
17902 
 
17903 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17904 
 
17905 
  thrift_spec = (
17906 
  )
17907 
 
17908 
  def read(self, iprot):
17909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17911 
      return
17912 
    iprot.readStructBegin()
17913 
    while True:
17914 
      (fname, ftype, fid) = iprot.readFieldBegin()
17915 
      if ftype == TType.STOP:
17916 
        break
17917 
      else:
17918 
        iprot.skip(ftype)
17919 
      iprot.readFieldEnd()
17920 
    iprot.readStructEnd()
17921 
 
17922 
  def write(self, oprot):
17923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17925 
      return
17926 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17927 
    oprot.writeFieldStop()
17928 
    oprot.writeStructEnd()
17929 
 
17930 
  def validate(self):
17931 
    return
17932 
 
17933 
 
17934 
  def __repr__(self):
17935 
    L = ['%s=%r' % (key, value)
17936 
      for key, value in self.__dict__.iteritems()]
17937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17938 
 
17939 
  def __eq__(self, other):
17940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17941 
 
17942 
  def __ne__(self, other):
17943 
    return not (self == other)
17944 
 
17945 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17946 
  """
17947 
  Attributes:
4910 phani.kuma 17948 
   - providerId
17949 
  """
17950 
 
17951 
  thrift_spec = (
17952 
    None, # 0
17953 
    (1, TType.I64, 'providerId', None, None, ), # 1
17954 
  )
17955 
 
17956 
  def __init__(self, providerId=None,):
17957 
    self.providerId = providerId
17958 
 
17959 
  def read(self, iprot):
17960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17962 
      return
17963 
    iprot.readStructBegin()
17964 
    while True:
17965 
      (fname, ftype, fid) = iprot.readFieldBegin()
17966 
      if ftype == TType.STOP:
17967 
        break
17968 
      if fid == 1:
17969 
        if ftype == TType.I64:
17970 
          self.providerId = iprot.readI64();
17971 
        else:
17972 
          iprot.skip(ftype)
17973 
      else:
17974 
        iprot.skip(ftype)
17975 
      iprot.readFieldEnd()
17976 
    iprot.readStructEnd()
17977 
 
17978 
  def write(self, oprot):
17979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17981 
      return
17982 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17983 
    if self.providerId is not None:
17984 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17985 
      oprot.writeI64(self.providerId)
17986 
      oprot.writeFieldEnd()
17987 
    oprot.writeFieldStop()
17988 
    oprot.writeStructEnd()
17989 
 
17990 
  def validate(self):
17991 
    return
17992 
 
17993 
 
17994 
  def __repr__(self):
17995 
    L = ['%s=%r' % (key, value)
17996 
      for key, value in self.__dict__.iteritems()]
17997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17998 
 
17999 
  def __eq__(self, other):
18000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18001 
 
18002 
  def __ne__(self, other):
18003 
    return not (self == other)
18004 
 
18005 
class getReturnOrdersNotPickedUp_result:
18006 
  """
18007 
  Attributes:
4741 phani.kuma 18008 
   - success
18009 
  """
18010 
 
18011 
  thrift_spec = (
18012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18013 
  )
18014 
 
18015 
  def __init__(self, success=None,):
18016 
    self.success = success
18017 
 
18018 
  def read(self, iprot):
18019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18021 
      return
18022 
    iprot.readStructBegin()
18023 
    while True:
18024 
      (fname, ftype, fid) = iprot.readFieldBegin()
18025 
      if ftype == TType.STOP:
18026 
        break
18027 
      if fid == 0:
18028 
        if ftype == TType.LIST:
18029 
          self.success = []
6188 rajveer 18030 
          (_etype435, _size432) = iprot.readListBegin()
18031 
          for _i436 in xrange(_size432):
18032 
            _elem437 = Order()
18033 
            _elem437.read(iprot)
18034 
            self.success.append(_elem437)
4741 phani.kuma 18035 
          iprot.readListEnd()
18036 
        else:
18037 
          iprot.skip(ftype)
18038 
      else:
18039 
        iprot.skip(ftype)
18040 
      iprot.readFieldEnd()
18041 
    iprot.readStructEnd()
18042 
 
18043 
  def write(self, oprot):
18044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18046 
      return
4910 phani.kuma 18047 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18048 
    if self.success is not None:
18049 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18050 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18051 
      for iter438 in self.success:
18052 
        iter438.write(oprot)
4741 phani.kuma 18053 
      oprot.writeListEnd()
18054 
      oprot.writeFieldEnd()
18055 
    oprot.writeFieldStop()
18056 
    oprot.writeStructEnd()
18057 
 
18058 
  def validate(self):
18059 
    return
18060 
 
18061 
 
18062 
  def __repr__(self):
18063 
    L = ['%s=%r' % (key, value)
18064 
      for key, value in self.__dict__.iteritems()]
18065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18066 
 
18067 
  def __eq__(self, other):
18068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18069 
 
18070 
  def __ne__(self, other):
18071 
    return not (self == other)
18072 
 
2616 chandransh 18073 
class receiveReturn_args:
2591 chandransh 18074 
  """
18075 
  Attributes:
18076 
   - orderId
4479 rajveer 18077 
   - receiveCondition
2591 chandransh 18078 
  """
2536 chandransh 18079 
 
2591 chandransh 18080 
  thrift_spec = (
18081 
    None, # 0
18082 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18083 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18084 
  )
18085 
 
4479 rajveer 18086 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18087 
    self.orderId = orderId
4479 rajveer 18088 
    self.receiveCondition = receiveCondition
2591 chandransh 18089 
 
18090 
  def read(self, iprot):
18091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18093 
      return
18094 
    iprot.readStructBegin()
18095 
    while True:
18096 
      (fname, ftype, fid) = iprot.readFieldBegin()
18097 
      if ftype == TType.STOP:
18098 
        break
18099 
      if fid == 1:
18100 
        if ftype == TType.I64:
18101 
          self.orderId = iprot.readI64();
18102 
        else:
18103 
          iprot.skip(ftype)
4479 rajveer 18104 
      elif fid == 2:
18105 
        if ftype == TType.I64:
18106 
          self.receiveCondition = iprot.readI64();
18107 
        else:
18108 
          iprot.skip(ftype)
2591 chandransh 18109 
      else:
18110 
        iprot.skip(ftype)
18111 
      iprot.readFieldEnd()
18112 
    iprot.readStructEnd()
18113 
 
18114 
  def write(self, oprot):
18115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18117 
      return
2616 chandransh 18118 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18119 
    if self.orderId is not None:
2591 chandransh 18120 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18121 
      oprot.writeI64(self.orderId)
18122 
      oprot.writeFieldEnd()
4479 rajveer 18123 
    if self.receiveCondition is not None:
18124 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18125 
      oprot.writeI64(self.receiveCondition)
18126 
      oprot.writeFieldEnd()
2591 chandransh 18127 
    oprot.writeFieldStop()
18128 
    oprot.writeStructEnd()
18129 
 
3431 rajveer 18130 
  def validate(self):
18131 
    return
18132 
 
18133 
 
2591 chandransh 18134 
  def __repr__(self):
18135 
    L = ['%s=%r' % (key, value)
18136 
      for key, value in self.__dict__.iteritems()]
18137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18138 
 
18139 
  def __eq__(self, other):
18140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18141 
 
18142 
  def __ne__(self, other):
18143 
    return not (self == other)
18144 
 
2616 chandransh 18145 
class receiveReturn_result:
2591 chandransh 18146 
  """
18147 
  Attributes:
18148 
   - success
18149 
   - ex
18150 
  """
18151 
 
18152 
  thrift_spec = (
18153 
    (0, TType.BOOL, 'success', None, None, ), # 0
18154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18155 
  )
18156 
 
18157 
  def __init__(self, success=None, ex=None,):
18158 
    self.success = success
18159 
    self.ex = ex
18160 
 
18161 
  def read(self, iprot):
18162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18164 
      return
18165 
    iprot.readStructBegin()
18166 
    while True:
18167 
      (fname, ftype, fid) = iprot.readFieldBegin()
18168 
      if ftype == TType.STOP:
18169 
        break
18170 
      if fid == 0:
18171 
        if ftype == TType.BOOL:
18172 
          self.success = iprot.readBool();
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      elif fid == 1:
18176 
        if ftype == TType.STRUCT:
18177 
          self.ex = TransactionServiceException()
18178 
          self.ex.read(iprot)
18179 
        else:
18180 
          iprot.skip(ftype)
18181 
      else:
18182 
        iprot.skip(ftype)
18183 
      iprot.readFieldEnd()
18184 
    iprot.readStructEnd()
18185 
 
18186 
  def write(self, oprot):
18187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18189 
      return
2616 chandransh 18190 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18191 
    if self.success is not None:
2591 chandransh 18192 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18193 
      oprot.writeBool(self.success)
18194 
      oprot.writeFieldEnd()
3431 rajveer 18195 
    if self.ex is not None:
2591 chandransh 18196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18197 
      self.ex.write(oprot)
18198 
      oprot.writeFieldEnd()
18199 
    oprot.writeFieldStop()
18200 
    oprot.writeStructEnd()
18201 
 
3431 rajveer 18202 
  def validate(self):
18203 
    return
18204 
 
18205 
 
2591 chandransh 18206 
  def __repr__(self):
18207 
    L = ['%s=%r' % (key, value)
18208 
      for key, value in self.__dict__.iteritems()]
18209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18210 
 
18211 
  def __eq__(self, other):
18212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18213 
 
18214 
  def __ne__(self, other):
18215 
    return not (self == other)
18216 
 
18217 
class validateDoa_args:
18218 
  """
18219 
  Attributes:
18220 
   - orderId
18221 
   - isValid
18222 
  """
18223 
 
18224 
  thrift_spec = (
18225 
    None, # 0
18226 
    (1, TType.I64, 'orderId', None, None, ), # 1
18227 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18228 
  )
18229 
 
18230 
  def __init__(self, orderId=None, isValid=None,):
18231 
    self.orderId = orderId
18232 
    self.isValid = isValid
18233 
 
18234 
  def read(self, iprot):
18235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18237 
      return
18238 
    iprot.readStructBegin()
18239 
    while True:
18240 
      (fname, ftype, fid) = iprot.readFieldBegin()
18241 
      if ftype == TType.STOP:
18242 
        break
18243 
      if fid == 1:
18244 
        if ftype == TType.I64:
18245 
          self.orderId = iprot.readI64();
18246 
        else:
18247 
          iprot.skip(ftype)
18248 
      elif fid == 2:
18249 
        if ftype == TType.BOOL:
18250 
          self.isValid = iprot.readBool();
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('validateDoa_args')
3431 rajveer 18263 
    if self.orderId is not None:
2591 chandransh 18264 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18265 
      oprot.writeI64(self.orderId)
18266 
      oprot.writeFieldEnd()
3431 rajveer 18267 
    if self.isValid is not None:
2591 chandransh 18268 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18269 
      oprot.writeBool(self.isValid)
18270 
      oprot.writeFieldEnd()
18271 
    oprot.writeFieldStop()
18272 
    oprot.writeStructEnd()
18273 
 
3431 rajveer 18274 
  def validate(self):
18275 
    return
18276 
 
18277 
 
2591 chandransh 18278 
  def __repr__(self):
18279 
    L = ['%s=%r' % (key, value)
18280 
      for key, value in self.__dict__.iteritems()]
18281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18282 
 
18283 
  def __eq__(self, other):
18284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18285 
 
18286 
  def __ne__(self, other):
18287 
    return not (self == other)
18288 
 
18289 
class validateDoa_result:
18290 
  """
18291 
  Attributes:
18292 
   - success
18293 
   - ex
18294 
  """
18295 
 
18296 
  thrift_spec = (
18297 
    (0, TType.BOOL, 'success', None, None, ), # 0
18298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18299 
  )
18300 
 
18301 
  def __init__(self, success=None, ex=None,):
18302 
    self.success = success
18303 
    self.ex = ex
18304 
 
18305 
  def read(self, iprot):
18306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18308 
      return
18309 
    iprot.readStructBegin()
18310 
    while True:
18311 
      (fname, ftype, fid) = iprot.readFieldBegin()
18312 
      if ftype == TType.STOP:
18313 
        break
18314 
      if fid == 0:
18315 
        if ftype == TType.BOOL:
18316 
          self.success = iprot.readBool();
18317 
        else:
18318 
          iprot.skip(ftype)
18319 
      elif fid == 1:
18320 
        if ftype == TType.STRUCT:
18321 
          self.ex = TransactionServiceException()
18322 
          self.ex.read(iprot)
18323 
        else:
18324 
          iprot.skip(ftype)
18325 
      else:
18326 
        iprot.skip(ftype)
18327 
      iprot.readFieldEnd()
18328 
    iprot.readStructEnd()
18329 
 
18330 
  def write(self, oprot):
18331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18333 
      return
18334 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18335 
    if self.success is not None:
2591 chandransh 18336 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18337 
      oprot.writeBool(self.success)
18338 
      oprot.writeFieldEnd()
3431 rajveer 18339 
    if self.ex is not None:
2591 chandransh 18340 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18341 
      self.ex.write(oprot)
18342 
      oprot.writeFieldEnd()
18343 
    oprot.writeFieldStop()
18344 
    oprot.writeStructEnd()
18345 
 
3431 rajveer 18346 
  def validate(self):
18347 
    return
18348 
 
18349 
 
2591 chandransh 18350 
  def __repr__(self):
18351 
    L = ['%s=%r' % (key, value)
18352 
      for key, value in self.__dict__.iteritems()]
18353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18354 
 
18355 
  def __eq__(self, other):
18356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18357 
 
18358 
  def __ne__(self, other):
18359 
    return not (self == other)
18360 
 
4495 rajveer 18361 
class validateReturnProduct_args:
18362 
  """
18363 
  Attributes:
18364 
   - orderId
18365 
   - isUsable
18366 
  """
18367 
 
18368 
  thrift_spec = (
18369 
    None, # 0
18370 
    (1, TType.I64, 'orderId', None, None, ), # 1
18371 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18372 
  )
18373 
 
18374 
  def __init__(self, orderId=None, isUsable=None,):
18375 
    self.orderId = orderId
18376 
    self.isUsable = isUsable
18377 
 
18378 
  def read(self, iprot):
18379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18381 
      return
18382 
    iprot.readStructBegin()
18383 
    while True:
18384 
      (fname, ftype, fid) = iprot.readFieldBegin()
18385 
      if ftype == TType.STOP:
18386 
        break
18387 
      if fid == 1:
18388 
        if ftype == TType.I64:
18389 
          self.orderId = iprot.readI64();
18390 
        else:
18391 
          iprot.skip(ftype)
18392 
      elif fid == 2:
18393 
        if ftype == TType.BOOL:
18394 
          self.isUsable = iprot.readBool();
18395 
        else:
18396 
          iprot.skip(ftype)
18397 
      else:
18398 
        iprot.skip(ftype)
18399 
      iprot.readFieldEnd()
18400 
    iprot.readStructEnd()
18401 
 
18402 
  def write(self, oprot):
18403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18405 
      return
18406 
    oprot.writeStructBegin('validateReturnProduct_args')
18407 
    if self.orderId is not None:
18408 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18409 
      oprot.writeI64(self.orderId)
18410 
      oprot.writeFieldEnd()
18411 
    if self.isUsable is not None:
18412 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18413 
      oprot.writeBool(self.isUsable)
18414 
      oprot.writeFieldEnd()
18415 
    oprot.writeFieldStop()
18416 
    oprot.writeStructEnd()
18417 
 
18418 
  def validate(self):
18419 
    return
18420 
 
18421 
 
18422 
  def __repr__(self):
18423 
    L = ['%s=%r' % (key, value)
18424 
      for key, value in self.__dict__.iteritems()]
18425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18426 
 
18427 
  def __eq__(self, other):
18428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18429 
 
18430 
  def __ne__(self, other):
18431 
    return not (self == other)
18432 
 
18433 
class validateReturnProduct_result:
18434 
  """
18435 
  Attributes:
18436 
   - success
18437 
   - ex
18438 
  """
18439 
 
18440 
  thrift_spec = (
18441 
    (0, TType.BOOL, 'success', None, None, ), # 0
18442 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18443 
  )
18444 
 
18445 
  def __init__(self, success=None, ex=None,):
18446 
    self.success = success
18447 
    self.ex = ex
18448 
 
18449 
  def read(self, iprot):
18450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18452 
      return
18453 
    iprot.readStructBegin()
18454 
    while True:
18455 
      (fname, ftype, fid) = iprot.readFieldBegin()
18456 
      if ftype == TType.STOP:
18457 
        break
18458 
      if fid == 0:
18459 
        if ftype == TType.BOOL:
18460 
          self.success = iprot.readBool();
18461 
        else:
18462 
          iprot.skip(ftype)
18463 
      elif fid == 1:
18464 
        if ftype == TType.STRUCT:
18465 
          self.ex = TransactionServiceException()
18466 
          self.ex.read(iprot)
18467 
        else:
18468 
          iprot.skip(ftype)
18469 
      else:
18470 
        iprot.skip(ftype)
18471 
      iprot.readFieldEnd()
18472 
    iprot.readStructEnd()
18473 
 
18474 
  def write(self, oprot):
18475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18477 
      return
18478 
    oprot.writeStructBegin('validateReturnProduct_result')
18479 
    if self.success is not None:
18480 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18481 
      oprot.writeBool(self.success)
18482 
      oprot.writeFieldEnd()
18483 
    if self.ex is not None:
18484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18485 
      self.ex.write(oprot)
18486 
      oprot.writeFieldEnd()
18487 
    oprot.writeFieldStop()
18488 
    oprot.writeStructEnd()
18489 
 
18490 
  def validate(self):
18491 
    return
18492 
 
18493 
 
18494 
  def __repr__(self):
18495 
    L = ['%s=%r' % (key, value)
18496 
      for key, value in self.__dict__.iteritems()]
18497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18498 
 
18499 
  def __eq__(self, other):
18500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18501 
 
18502 
  def __ne__(self, other):
18503 
    return not (self == other)
18504 
 
2616 chandransh 18505 
class reshipOrder_args:
18506 
  """
18507 
  Attributes:
18508 
   - orderId
18509 
  """
2591 chandransh 18510 
 
2616 chandransh 18511 
  thrift_spec = (
18512 
    None, # 0
18513 
    (1, TType.I64, 'orderId', None, None, ), # 1
18514 
  )
18515 
 
18516 
  def __init__(self, orderId=None,):
18517 
    self.orderId = orderId
18518 
 
18519 
  def read(self, iprot):
18520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18522 
      return
18523 
    iprot.readStructBegin()
18524 
    while True:
18525 
      (fname, ftype, fid) = iprot.readFieldBegin()
18526 
      if ftype == TType.STOP:
18527 
        break
18528 
      if fid == 1:
18529 
        if ftype == TType.I64:
18530 
          self.orderId = iprot.readI64();
18531 
        else:
18532 
          iprot.skip(ftype)
18533 
      else:
18534 
        iprot.skip(ftype)
18535 
      iprot.readFieldEnd()
18536 
    iprot.readStructEnd()
18537 
 
18538 
  def write(self, oprot):
18539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18541 
      return
18542 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18543 
    if self.orderId is not None:
2616 chandransh 18544 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18545 
      oprot.writeI64(self.orderId)
18546 
      oprot.writeFieldEnd()
18547 
    oprot.writeFieldStop()
18548 
    oprot.writeStructEnd()
18549 
 
3431 rajveer 18550 
  def validate(self):
18551 
    return
18552 
 
18553 
 
2616 chandransh 18554 
  def __repr__(self):
18555 
    L = ['%s=%r' % (key, value)
18556 
      for key, value in self.__dict__.iteritems()]
18557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18558 
 
18559 
  def __eq__(self, other):
18560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18561 
 
18562 
  def __ne__(self, other):
18563 
    return not (self == other)
18564 
 
18565 
class reshipOrder_result:
18566 
  """
18567 
  Attributes:
18568 
   - success
18569 
   - ex
18570 
  """
18571 
 
18572 
  thrift_spec = (
18573 
    (0, TType.I64, 'success', None, None, ), # 0
18574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18575 
  )
18576 
 
18577 
  def __init__(self, success=None, ex=None,):
18578 
    self.success = success
18579 
    self.ex = ex
18580 
 
18581 
  def read(self, iprot):
18582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18584 
      return
18585 
    iprot.readStructBegin()
18586 
    while True:
18587 
      (fname, ftype, fid) = iprot.readFieldBegin()
18588 
      if ftype == TType.STOP:
18589 
        break
18590 
      if fid == 0:
18591 
        if ftype == TType.I64:
18592 
          self.success = iprot.readI64();
18593 
        else:
18594 
          iprot.skip(ftype)
18595 
      elif fid == 1:
18596 
        if ftype == TType.STRUCT:
18597 
          self.ex = TransactionServiceException()
18598 
          self.ex.read(iprot)
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('reshipOrder_result')
3431 rajveer 18611 
    if self.success is not None:
2616 chandransh 18612 
      oprot.writeFieldBegin('success', TType.I64, 0)
18613 
      oprot.writeI64(self.success)
18614 
      oprot.writeFieldEnd()
3431 rajveer 18615 
    if self.ex is not None:
2616 chandransh 18616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18617 
      self.ex.write(oprot)
18618 
      oprot.writeFieldEnd()
18619 
    oprot.writeFieldStop()
18620 
    oprot.writeStructEnd()
18621 
 
3431 rajveer 18622 
  def validate(self):
18623 
    return
18624 
 
18625 
 
2616 chandransh 18626 
  def __repr__(self):
18627 
    L = ['%s=%r' % (key, value)
18628 
      for key, value in self.__dict__.iteritems()]
18629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18630 
 
18631 
  def __eq__(self, other):
18632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18633 
 
18634 
  def __ne__(self, other):
18635 
    return not (self == other)
18636 
 
18637 
class refundOrder_args:
18638 
  """
18639 
  Attributes:
18640 
   - orderId
3226 chandransh 18641 
   - refundedBy
18642 
   - reason
2616 chandransh 18643 
  """
18644 
 
18645 
  thrift_spec = (
18646 
    None, # 0
18647 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18648 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18649 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18650 
  )
18651 
 
3226 chandransh 18652 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18653 
    self.orderId = orderId
3226 chandransh 18654 
    self.refundedBy = refundedBy
18655 
    self.reason = reason
2616 chandransh 18656 
 
18657 
  def read(self, iprot):
18658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18660 
      return
18661 
    iprot.readStructBegin()
18662 
    while True:
18663 
      (fname, ftype, fid) = iprot.readFieldBegin()
18664 
      if ftype == TType.STOP:
18665 
        break
18666 
      if fid == 1:
18667 
        if ftype == TType.I64:
18668 
          self.orderId = iprot.readI64();
18669 
        else:
18670 
          iprot.skip(ftype)
3226 chandransh 18671 
      elif fid == 2:
18672 
        if ftype == TType.STRING:
18673 
          self.refundedBy = iprot.readString();
18674 
        else:
18675 
          iprot.skip(ftype)
18676 
      elif fid == 3:
18677 
        if ftype == TType.STRING:
18678 
          self.reason = iprot.readString();
18679 
        else:
18680 
          iprot.skip(ftype)
2616 chandransh 18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18691 
    if self.orderId is not None:
2616 chandransh 18692 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18693 
      oprot.writeI64(self.orderId)
18694 
      oprot.writeFieldEnd()
3431 rajveer 18695 
    if self.refundedBy is not None:
3226 chandransh 18696 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18697 
      oprot.writeString(self.refundedBy)
18698 
      oprot.writeFieldEnd()
3431 rajveer 18699 
    if self.reason is not None:
3226 chandransh 18700 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18701 
      oprot.writeString(self.reason)
18702 
      oprot.writeFieldEnd()
2616 chandransh 18703 
    oprot.writeFieldStop()
18704 
    oprot.writeStructEnd()
18705 
 
3431 rajveer 18706 
  def validate(self):
18707 
    return
18708 
 
18709 
 
2616 chandransh 18710 
  def __repr__(self):
18711 
    L = ['%s=%r' % (key, value)
18712 
      for key, value in self.__dict__.iteritems()]
18713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18714 
 
18715 
  def __eq__(self, other):
18716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18717 
 
18718 
  def __ne__(self, other):
18719 
    return not (self == other)
18720 
 
18721 
class refundOrder_result:
18722 
  """
18723 
  Attributes:
18724 
   - success
18725 
   - ex
18726 
  """
18727 
 
18728 
  thrift_spec = (
18729 
    (0, TType.BOOL, 'success', None, None, ), # 0
18730 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18731 
  )
18732 
 
18733 
  def __init__(self, success=None, ex=None,):
18734 
    self.success = success
18735 
    self.ex = ex
18736 
 
18737 
  def read(self, iprot):
18738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18740 
      return
18741 
    iprot.readStructBegin()
18742 
    while True:
18743 
      (fname, ftype, fid) = iprot.readFieldBegin()
18744 
      if ftype == TType.STOP:
18745 
        break
18746 
      if fid == 0:
18747 
        if ftype == TType.BOOL:
18748 
          self.success = iprot.readBool();
18749 
        else:
18750 
          iprot.skip(ftype)
18751 
      elif fid == 1:
18752 
        if ftype == TType.STRUCT:
18753 
          self.ex = TransactionServiceException()
18754 
          self.ex.read(iprot)
18755 
        else:
18756 
          iprot.skip(ftype)
18757 
      else:
18758 
        iprot.skip(ftype)
18759 
      iprot.readFieldEnd()
18760 
    iprot.readStructEnd()
18761 
 
18762 
  def write(self, oprot):
18763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18765 
      return
18766 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18767 
    if self.success is not None:
2616 chandransh 18768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18769 
      oprot.writeBool(self.success)
18770 
      oprot.writeFieldEnd()
3431 rajveer 18771 
    if self.ex is not None:
2616 chandransh 18772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18773 
      self.ex.write(oprot)
18774 
      oprot.writeFieldEnd()
18775 
    oprot.writeFieldStop()
18776 
    oprot.writeStructEnd()
18777 
 
3431 rajveer 18778 
  def validate(self):
18779 
    return
18780 
 
18781 
 
2616 chandransh 18782 
  def __repr__(self):
18783 
    L = ['%s=%r' % (key, value)
18784 
      for key, value in self.__dict__.iteritems()]
18785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18786 
 
18787 
  def __eq__(self, other):
18788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18789 
 
18790 
  def __ne__(self, other):
18791 
    return not (self == other)
18792 
 
2690 chandransh 18793 
class getReturnOrders_args:
18794 
  """
18795 
  Attributes:
18796 
   - warehouseId
18797 
   - fromDate
18798 
   - toDate
18799 
  """
2616 chandransh 18800 
 
2690 chandransh 18801 
  thrift_spec = (
18802 
    None, # 0
18803 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18804 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18805 
    (3, TType.I64, 'toDate', None, None, ), # 3
18806 
  )
18807 
 
18808 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18809 
    self.warehouseId = warehouseId
18810 
    self.fromDate = fromDate
18811 
    self.toDate = toDate
18812 
 
18813 
  def read(self, iprot):
18814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18816 
      return
18817 
    iprot.readStructBegin()
18818 
    while True:
18819 
      (fname, ftype, fid) = iprot.readFieldBegin()
18820 
      if ftype == TType.STOP:
18821 
        break
18822 
      if fid == 1:
18823 
        if ftype == TType.I64:
18824 
          self.warehouseId = iprot.readI64();
18825 
        else:
18826 
          iprot.skip(ftype)
18827 
      elif fid == 2:
18828 
        if ftype == TType.I64:
18829 
          self.fromDate = iprot.readI64();
18830 
        else:
18831 
          iprot.skip(ftype)
18832 
      elif fid == 3:
18833 
        if ftype == TType.I64:
18834 
          self.toDate = iprot.readI64();
18835 
        else:
18836 
          iprot.skip(ftype)
18837 
      else:
18838 
        iprot.skip(ftype)
18839 
      iprot.readFieldEnd()
18840 
    iprot.readStructEnd()
18841 
 
18842 
  def write(self, oprot):
18843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18845 
      return
18846 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18847 
    if self.warehouseId is not None:
2690 chandransh 18848 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18849 
      oprot.writeI64(self.warehouseId)
18850 
      oprot.writeFieldEnd()
3431 rajveer 18851 
    if self.fromDate is not None:
2690 chandransh 18852 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18853 
      oprot.writeI64(self.fromDate)
18854 
      oprot.writeFieldEnd()
3431 rajveer 18855 
    if self.toDate is not None:
2690 chandransh 18856 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18857 
      oprot.writeI64(self.toDate)
18858 
      oprot.writeFieldEnd()
18859 
    oprot.writeFieldStop()
18860 
    oprot.writeStructEnd()
18861 
 
3431 rajveer 18862 
  def validate(self):
18863 
    return
18864 
 
18865 
 
2690 chandransh 18866 
  def __repr__(self):
18867 
    L = ['%s=%r' % (key, value)
18868 
      for key, value in self.__dict__.iteritems()]
18869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18870 
 
18871 
  def __eq__(self, other):
18872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18873 
 
18874 
  def __ne__(self, other):
18875 
    return not (self == other)
18876 
 
18877 
class getReturnOrders_result:
18878 
  """
18879 
  Attributes:
18880 
   - success
18881 
  """
18882 
 
18883 
  thrift_spec = (
18884 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18885 
  )
18886 
 
18887 
  def __init__(self, success=None,):
18888 
    self.success = success
18889 
 
18890 
  def read(self, iprot):
18891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18893 
      return
18894 
    iprot.readStructBegin()
18895 
    while True:
18896 
      (fname, ftype, fid) = iprot.readFieldBegin()
18897 
      if ftype == TType.STOP:
18898 
        break
18899 
      if fid == 0:
18900 
        if ftype == TType.LIST:
18901 
          self.success = []
6188 rajveer 18902 
          (_etype442, _size439) = iprot.readListBegin()
18903 
          for _i443 in xrange(_size439):
18904 
            _elem444 = ReturnOrder()
18905 
            _elem444.read(iprot)
18906 
            self.success.append(_elem444)
2690 chandransh 18907 
          iprot.readListEnd()
18908 
        else:
18909 
          iprot.skip(ftype)
18910 
      else:
18911 
        iprot.skip(ftype)
18912 
      iprot.readFieldEnd()
18913 
    iprot.readStructEnd()
18914 
 
18915 
  def write(self, oprot):
18916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18918 
      return
18919 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18920 
    if self.success is not None:
2690 chandransh 18921 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18922 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18923 
      for iter445 in self.success:
18924 
        iter445.write(oprot)
2690 chandransh 18925 
      oprot.writeListEnd()
18926 
      oprot.writeFieldEnd()
18927 
    oprot.writeFieldStop()
18928 
    oprot.writeStructEnd()
18929 
 
3431 rajveer 18930 
  def validate(self):
18931 
    return
18932 
 
18933 
 
2690 chandransh 18934 
  def __repr__(self):
18935 
    L = ['%s=%r' % (key, value)
18936 
      for key, value in self.__dict__.iteritems()]
18937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18938 
 
18939 
  def __eq__(self, other):
18940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18941 
 
18942 
  def __ne__(self, other):
18943 
    return not (self == other)
18944 
 
5481 phani.kuma 18945 
class getAllReturnOrders_args:
18946 
  """
18947 
  Attributes:
18948 
   - onlyNotProcessed
18949 
   - fromDate
18950 
   - toDate
18951 
  """
18952 
 
18953 
  thrift_spec = (
18954 
    None, # 0
18955 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18956 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18957 
    (3, TType.I64, 'toDate', None, None, ), # 3
18958 
  )
18959 
 
18960 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18961 
    self.onlyNotProcessed = onlyNotProcessed
18962 
    self.fromDate = fromDate
18963 
    self.toDate = toDate
18964 
 
18965 
  def read(self, iprot):
18966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18968 
      return
18969 
    iprot.readStructBegin()
18970 
    while True:
18971 
      (fname, ftype, fid) = iprot.readFieldBegin()
18972 
      if ftype == TType.STOP:
18973 
        break
18974 
      if fid == 1:
18975 
        if ftype == TType.BOOL:
18976 
          self.onlyNotProcessed = iprot.readBool();
18977 
        else:
18978 
          iprot.skip(ftype)
18979 
      elif fid == 2:
18980 
        if ftype == TType.I64:
18981 
          self.fromDate = iprot.readI64();
18982 
        else:
18983 
          iprot.skip(ftype)
18984 
      elif fid == 3:
18985 
        if ftype == TType.I64:
18986 
          self.toDate = iprot.readI64();
18987 
        else:
18988 
          iprot.skip(ftype)
18989 
      else:
18990 
        iprot.skip(ftype)
18991 
      iprot.readFieldEnd()
18992 
    iprot.readStructEnd()
18993 
 
18994 
  def write(self, oprot):
18995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18997 
      return
18998 
    oprot.writeStructBegin('getAllReturnOrders_args')
18999 
    if self.onlyNotProcessed is not None:
19000 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19001 
      oprot.writeBool(self.onlyNotProcessed)
19002 
      oprot.writeFieldEnd()
19003 
    if self.fromDate is not None:
19004 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19005 
      oprot.writeI64(self.fromDate)
19006 
      oprot.writeFieldEnd()
19007 
    if self.toDate is not None:
19008 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19009 
      oprot.writeI64(self.toDate)
19010 
      oprot.writeFieldEnd()
19011 
    oprot.writeFieldStop()
19012 
    oprot.writeStructEnd()
19013 
 
19014 
  def validate(self):
19015 
    return
19016 
 
19017 
 
19018 
  def __repr__(self):
19019 
    L = ['%s=%r' % (key, value)
19020 
      for key, value in self.__dict__.iteritems()]
19021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19022 
 
19023 
  def __eq__(self, other):
19024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19025 
 
19026 
  def __ne__(self, other):
19027 
    return not (self == other)
19028 
 
19029 
class getAllReturnOrders_result:
19030 
  """
19031 
  Attributes:
19032 
   - success
19033 
  """
19034 
 
19035 
  thrift_spec = (
19036 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19037 
  )
19038 
 
19039 
  def __init__(self, success=None,):
19040 
    self.success = success
19041 
 
19042 
  def read(self, iprot):
19043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19045 
      return
19046 
    iprot.readStructBegin()
19047 
    while True:
19048 
      (fname, ftype, fid) = iprot.readFieldBegin()
19049 
      if ftype == TType.STOP:
19050 
        break
19051 
      if fid == 0:
19052 
        if ftype == TType.LIST:
19053 
          self.success = []
6188 rajveer 19054 
          (_etype449, _size446) = iprot.readListBegin()
19055 
          for _i450 in xrange(_size446):
19056 
            _elem451 = ReturnOrder()
19057 
            _elem451.read(iprot)
19058 
            self.success.append(_elem451)
5481 phani.kuma 19059 
          iprot.readListEnd()
19060 
        else:
19061 
          iprot.skip(ftype)
19062 
      else:
19063 
        iprot.skip(ftype)
19064 
      iprot.readFieldEnd()
19065 
    iprot.readStructEnd()
19066 
 
19067 
  def write(self, oprot):
19068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19070 
      return
19071 
    oprot.writeStructBegin('getAllReturnOrders_result')
19072 
    if self.success is not None:
19073 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19074 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19075 
      for iter452 in self.success:
19076 
        iter452.write(oprot)
5481 phani.kuma 19077 
      oprot.writeListEnd()
19078 
      oprot.writeFieldEnd()
19079 
    oprot.writeFieldStop()
19080 
    oprot.writeStructEnd()
19081 
 
19082 
  def validate(self):
19083 
    return
19084 
 
19085 
 
19086 
  def __repr__(self):
19087 
    L = ['%s=%r' % (key, value)
19088 
      for key, value in self.__dict__.iteritems()]
19089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19090 
 
19091 
  def __eq__(self, other):
19092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19093 
 
19094 
  def __ne__(self, other):
19095 
    return not (self == other)
19096 
 
2700 chandransh 19097 
class getReturnOrder_args:
19098 
  """
19099 
  Attributes:
19100 
   - id
19101 
  """
19102 
 
19103 
  thrift_spec = (
19104 
    None, # 0
19105 
    (1, TType.I64, 'id', None, None, ), # 1
19106 
  )
19107 
 
19108 
  def __init__(self, id=None,):
19109 
    self.id = id
19110 
 
19111 
  def read(self, iprot):
19112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19114 
      return
19115 
    iprot.readStructBegin()
19116 
    while True:
19117 
      (fname, ftype, fid) = iprot.readFieldBegin()
19118 
      if ftype == TType.STOP:
19119 
        break
19120 
      if fid == 1:
19121 
        if ftype == TType.I64:
19122 
          self.id = iprot.readI64();
19123 
        else:
19124 
          iprot.skip(ftype)
19125 
      else:
19126 
        iprot.skip(ftype)
19127 
      iprot.readFieldEnd()
19128 
    iprot.readStructEnd()
19129 
 
19130 
  def write(self, oprot):
19131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19133 
      return
19134 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19135 
    if self.id is not None:
2700 chandransh 19136 
      oprot.writeFieldBegin('id', TType.I64, 1)
19137 
      oprot.writeI64(self.id)
19138 
      oprot.writeFieldEnd()
19139 
    oprot.writeFieldStop()
19140 
    oprot.writeStructEnd()
19141 
 
3431 rajveer 19142 
  def validate(self):
19143 
    return
19144 
 
19145 
 
2700 chandransh 19146 
  def __repr__(self):
19147 
    L = ['%s=%r' % (key, value)
19148 
      for key, value in self.__dict__.iteritems()]
19149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19150 
 
19151 
  def __eq__(self, other):
19152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19153 
 
19154 
  def __ne__(self, other):
19155 
    return not (self == other)
19156 
 
19157 
class getReturnOrder_result:
19158 
  """
19159 
  Attributes:
19160 
   - success
19161 
   - ex
19162 
  """
19163 
 
19164 
  thrift_spec = (
19165 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19167 
  )
19168 
 
19169 
  def __init__(self, success=None, ex=None,):
19170 
    self.success = success
19171 
    self.ex = ex
19172 
 
19173 
  def read(self, iprot):
19174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19176 
      return
19177 
    iprot.readStructBegin()
19178 
    while True:
19179 
      (fname, ftype, fid) = iprot.readFieldBegin()
19180 
      if ftype == TType.STOP:
19181 
        break
19182 
      if fid == 0:
19183 
        if ftype == TType.STRUCT:
19184 
          self.success = ReturnOrder()
19185 
          self.success.read(iprot)
19186 
        else:
19187 
          iprot.skip(ftype)
19188 
      elif fid == 1:
19189 
        if ftype == TType.STRUCT:
19190 
          self.ex = TransactionServiceException()
19191 
          self.ex.read(iprot)
19192 
        else:
19193 
          iprot.skip(ftype)
19194 
      else:
19195 
        iprot.skip(ftype)
19196 
      iprot.readFieldEnd()
19197 
    iprot.readStructEnd()
19198 
 
19199 
  def write(self, oprot):
19200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19202 
      return
19203 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19204 
    if self.success is not None:
2700 chandransh 19205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19206 
      self.success.write(oprot)
19207 
      oprot.writeFieldEnd()
3431 rajveer 19208 
    if self.ex is not None:
2700 chandransh 19209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19210 
      self.ex.write(oprot)
19211 
      oprot.writeFieldEnd()
19212 
    oprot.writeFieldStop()
19213 
    oprot.writeStructEnd()
19214 
 
3431 rajveer 19215 
  def validate(self):
19216 
    return
19217 
 
19218 
 
2700 chandransh 19219 
  def __repr__(self):
19220 
    L = ['%s=%r' % (key, value)
19221 
      for key, value in self.__dict__.iteritems()]
19222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19223 
 
19224 
  def __eq__(self, other):
19225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19226 
 
19227 
  def __ne__(self, other):
19228 
    return not (self == other)
19229 
 
2690 chandransh 19230 
class processReturn_args:
19231 
  """
19232 
  Attributes:
19233 
   - returnOrderId
19234 
  """
19235 
 
19236 
  thrift_spec = (
19237 
    None, # 0
19238 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19239 
  )
19240 
 
19241 
  def __init__(self, returnOrderId=None,):
19242 
    self.returnOrderId = returnOrderId
19243 
 
19244 
  def read(self, iprot):
19245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19247 
      return
19248 
    iprot.readStructBegin()
19249 
    while True:
19250 
      (fname, ftype, fid) = iprot.readFieldBegin()
19251 
      if ftype == TType.STOP:
19252 
        break
19253 
      if fid == 1:
19254 
        if ftype == TType.I64:
19255 
          self.returnOrderId = iprot.readI64();
19256 
        else:
19257 
          iprot.skip(ftype)
19258 
      else:
19259 
        iprot.skip(ftype)
19260 
      iprot.readFieldEnd()
19261 
    iprot.readStructEnd()
19262 
 
19263 
  def write(self, oprot):
19264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19266 
      return
19267 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19268 
    if self.returnOrderId is not None:
2690 chandransh 19269 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19270 
      oprot.writeI64(self.returnOrderId)
19271 
      oprot.writeFieldEnd()
19272 
    oprot.writeFieldStop()
19273 
    oprot.writeStructEnd()
19274 
 
3431 rajveer 19275 
  def validate(self):
19276 
    return
19277 
 
19278 
 
2690 chandransh 19279 
  def __repr__(self):
19280 
    L = ['%s=%r' % (key, value)
19281 
      for key, value in self.__dict__.iteritems()]
19282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19283 
 
19284 
  def __eq__(self, other):
19285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19286 
 
19287 
  def __ne__(self, other):
19288 
    return not (self == other)
19289 
 
19290 
class processReturn_result:
19291 
  """
19292 
  Attributes:
19293 
   - ex
19294 
  """
19295 
 
19296 
  thrift_spec = (
19297 
    None, # 0
19298 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19299 
  )
19300 
 
19301 
  def __init__(self, ex=None,):
19302 
    self.ex = ex
19303 
 
19304 
  def read(self, iprot):
19305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19307 
      return
19308 
    iprot.readStructBegin()
19309 
    while True:
19310 
      (fname, ftype, fid) = iprot.readFieldBegin()
19311 
      if ftype == TType.STOP:
19312 
        break
19313 
      if fid == 1:
19314 
        if ftype == TType.STRUCT:
19315 
          self.ex = TransactionServiceException()
19316 
          self.ex.read(iprot)
19317 
        else:
19318 
          iprot.skip(ftype)
19319 
      else:
19320 
        iprot.skip(ftype)
19321 
      iprot.readFieldEnd()
19322 
    iprot.readStructEnd()
19323 
 
19324 
  def write(self, oprot):
19325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19327 
      return
19328 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19329 
    if self.ex is not None:
2690 chandransh 19330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19331 
      self.ex.write(oprot)
19332 
      oprot.writeFieldEnd()
19333 
    oprot.writeFieldStop()
19334 
    oprot.writeStructEnd()
19335 
 
3431 rajveer 19336 
  def validate(self):
19337 
    return
19338 
 
19339 
 
2690 chandransh 19340 
  def __repr__(self):
19341 
    L = ['%s=%r' % (key, value)
19342 
      for key, value in self.__dict__.iteritems()]
19343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19344 
 
19345 
  def __eq__(self, other):
19346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19347 
 
19348 
  def __ne__(self, other):
19349 
    return not (self == other)
19350 
 
3451 chandransh 19351 
class updateWeight_args:
19352 
  """
19353 
  Attributes:
19354 
   - orderId
19355 
   - weight
19356 
  """
19357 
 
19358 
  thrift_spec = (
19359 
    None, # 0
19360 
    (1, TType.I64, 'orderId', None, None, ), # 1
19361 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19362 
  )
19363 
 
19364 
  def __init__(self, orderId=None, weight=None,):
19365 
    self.orderId = orderId
19366 
    self.weight = weight
19367 
 
19368 
  def read(self, iprot):
19369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19371 
      return
19372 
    iprot.readStructBegin()
19373 
    while True:
19374 
      (fname, ftype, fid) = iprot.readFieldBegin()
19375 
      if ftype == TType.STOP:
19376 
        break
19377 
      if fid == 1:
19378 
        if ftype == TType.I64:
19379 
          self.orderId = iprot.readI64();
19380 
        else:
19381 
          iprot.skip(ftype)
19382 
      elif fid == 2:
19383 
        if ftype == TType.DOUBLE:
19384 
          self.weight = iprot.readDouble();
19385 
        else:
19386 
          iprot.skip(ftype)
19387 
      else:
19388 
        iprot.skip(ftype)
19389 
      iprot.readFieldEnd()
19390 
    iprot.readStructEnd()
19391 
 
19392 
  def write(self, oprot):
19393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19395 
      return
19396 
    oprot.writeStructBegin('updateWeight_args')
19397 
    if self.orderId is not None:
19398 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19399 
      oprot.writeI64(self.orderId)
19400 
      oprot.writeFieldEnd()
19401 
    if self.weight is not None:
19402 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19403 
      oprot.writeDouble(self.weight)
19404 
      oprot.writeFieldEnd()
19405 
    oprot.writeFieldStop()
19406 
    oprot.writeStructEnd()
19407 
 
19408 
  def validate(self):
19409 
    return
19410 
 
19411 
 
19412 
  def __repr__(self):
19413 
    L = ['%s=%r' % (key, value)
19414 
      for key, value in self.__dict__.iteritems()]
19415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19416 
 
19417 
  def __eq__(self, other):
19418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19419 
 
19420 
  def __ne__(self, other):
19421 
    return not (self == other)
19422 
 
19423 
class updateWeight_result:
19424 
  """
19425 
  Attributes:
19426 
   - success
19427 
   - ex
19428 
  """
19429 
 
19430 
  thrift_spec = (
19431 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19433 
  )
19434 
 
19435 
  def __init__(self, success=None, ex=None,):
19436 
    self.success = success
19437 
    self.ex = ex
19438 
 
19439 
  def read(self, iprot):
19440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19442 
      return
19443 
    iprot.readStructBegin()
19444 
    while True:
19445 
      (fname, ftype, fid) = iprot.readFieldBegin()
19446 
      if ftype == TType.STOP:
19447 
        break
19448 
      if fid == 0:
19449 
        if ftype == TType.STRUCT:
19450 
          self.success = Order()
19451 
          self.success.read(iprot)
19452 
        else:
19453 
          iprot.skip(ftype)
19454 
      elif fid == 1:
19455 
        if ftype == TType.STRUCT:
19456 
          self.ex = TransactionServiceException()
19457 
          self.ex.read(iprot)
19458 
        else:
19459 
          iprot.skip(ftype)
19460 
      else:
19461 
        iprot.skip(ftype)
19462 
      iprot.readFieldEnd()
19463 
    iprot.readStructEnd()
19464 
 
19465 
  def write(self, oprot):
19466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19468 
      return
19469 
    oprot.writeStructBegin('updateWeight_result')
19470 
    if self.success is not None:
19471 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19472 
      self.success.write(oprot)
19473 
      oprot.writeFieldEnd()
19474 
    if self.ex is not None:
19475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19476 
      self.ex.write(oprot)
19477 
      oprot.writeFieldEnd()
19478 
    oprot.writeFieldStop()
19479 
    oprot.writeStructEnd()
19480 
 
19481 
  def validate(self):
19482 
    return
19483 
 
19484 
 
19485 
  def __repr__(self):
19486 
    L = ['%s=%r' % (key, value)
19487 
      for key, value in self.__dict__.iteritems()]
19488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19489 
 
19490 
  def __eq__(self, other):
19491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19492 
 
19493 
  def __ne__(self, other):
19494 
    return not (self == other)
3469 chandransh 19495 
 
19496 
class changeItem_args:
19497 
  """
19498 
  Attributes:
19499 
   - orderId
19500 
   - itemId
19501 
  """
19502 
 
19503 
  thrift_spec = (
19504 
    None, # 0
19505 
    (1, TType.I64, 'orderId', None, None, ), # 1
19506 
    (2, TType.I64, 'itemId', None, None, ), # 2
19507 
  )
19508 
 
19509 
  def __init__(self, orderId=None, itemId=None,):
19510 
    self.orderId = orderId
19511 
    self.itemId = itemId
19512 
 
19513 
  def read(self, iprot):
19514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19516 
      return
19517 
    iprot.readStructBegin()
19518 
    while True:
19519 
      (fname, ftype, fid) = iprot.readFieldBegin()
19520 
      if ftype == TType.STOP:
19521 
        break
19522 
      if fid == 1:
19523 
        if ftype == TType.I64:
19524 
          self.orderId = iprot.readI64();
19525 
        else:
19526 
          iprot.skip(ftype)
19527 
      elif fid == 2:
19528 
        if ftype == TType.I64:
19529 
          self.itemId = iprot.readI64();
19530 
        else:
19531 
          iprot.skip(ftype)
19532 
      else:
19533 
        iprot.skip(ftype)
19534 
      iprot.readFieldEnd()
19535 
    iprot.readStructEnd()
19536 
 
19537 
  def write(self, oprot):
19538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19540 
      return
19541 
    oprot.writeStructBegin('changeItem_args')
19542 
    if self.orderId is not None:
19543 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19544 
      oprot.writeI64(self.orderId)
19545 
      oprot.writeFieldEnd()
19546 
    if self.itemId is not None:
19547 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19548 
      oprot.writeI64(self.itemId)
19549 
      oprot.writeFieldEnd()
19550 
    oprot.writeFieldStop()
19551 
    oprot.writeStructEnd()
19552 
 
19553 
  def validate(self):
19554 
    return
19555 
 
19556 
 
19557 
  def __repr__(self):
19558 
    L = ['%s=%r' % (key, value)
19559 
      for key, value in self.__dict__.iteritems()]
19560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19561 
 
19562 
  def __eq__(self, other):
19563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19564 
 
19565 
  def __ne__(self, other):
19566 
    return not (self == other)
19567 
 
19568 
class changeItem_result:
19569 
  """
19570 
  Attributes:
19571 
   - success
19572 
   - ex
19573 
  """
19574 
 
19575 
  thrift_spec = (
19576 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19577 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19578 
  )
19579 
 
19580 
  def __init__(self, success=None, ex=None,):
19581 
    self.success = success
19582 
    self.ex = ex
19583 
 
19584 
  def read(self, iprot):
19585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19587 
      return
19588 
    iprot.readStructBegin()
19589 
    while True:
19590 
      (fname, ftype, fid) = iprot.readFieldBegin()
19591 
      if ftype == TType.STOP:
19592 
        break
19593 
      if fid == 0:
19594 
        if ftype == TType.STRUCT:
19595 
          self.success = Order()
19596 
          self.success.read(iprot)
19597 
        else:
19598 
          iprot.skip(ftype)
19599 
      elif fid == 1:
19600 
        if ftype == TType.STRUCT:
19601 
          self.ex = TransactionServiceException()
19602 
          self.ex.read(iprot)
19603 
        else:
19604 
          iprot.skip(ftype)
19605 
      else:
19606 
        iprot.skip(ftype)
19607 
      iprot.readFieldEnd()
19608 
    iprot.readStructEnd()
19609 
 
19610 
  def write(self, oprot):
19611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19613 
      return
19614 
    oprot.writeStructBegin('changeItem_result')
19615 
    if self.success is not None:
19616 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19617 
      self.success.write(oprot)
19618 
      oprot.writeFieldEnd()
19619 
    if self.ex is not None:
19620 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19621 
      self.ex.write(oprot)
19622 
      oprot.writeFieldEnd()
19623 
    oprot.writeFieldStop()
19624 
    oprot.writeStructEnd()
19625 
 
19626 
  def validate(self):
19627 
    return
19628 
 
19629 
 
19630 
  def __repr__(self):
19631 
    L = ['%s=%r' % (key, value)
19632 
      for key, value in self.__dict__.iteritems()]
19633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19634 
 
19635 
  def __eq__(self, other):
19636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19637 
 
19638 
  def __ne__(self, other):
19639 
    return not (self == other)
19640 
 
19641 
class shiftToWarehouse_args:
19642 
  """
19643 
  Attributes:
19644 
   - orderId
19645 
   - warehouseId
19646 
  """
19647 
 
19648 
  thrift_spec = (
19649 
    None, # 0
19650 
    (1, TType.I64, 'orderId', None, None, ), # 1
19651 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19652 
  )
19653 
 
19654 
  def __init__(self, orderId=None, warehouseId=None,):
19655 
    self.orderId = orderId
19656 
    self.warehouseId = warehouseId
19657 
 
19658 
  def read(self, iprot):
19659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19661 
      return
19662 
    iprot.readStructBegin()
19663 
    while True:
19664 
      (fname, ftype, fid) = iprot.readFieldBegin()
19665 
      if ftype == TType.STOP:
19666 
        break
19667 
      if fid == 1:
19668 
        if ftype == TType.I64:
19669 
          self.orderId = iprot.readI64();
19670 
        else:
19671 
          iprot.skip(ftype)
19672 
      elif fid == 2:
19673 
        if ftype == TType.I64:
19674 
          self.warehouseId = iprot.readI64();
19675 
        else:
19676 
          iprot.skip(ftype)
19677 
      else:
19678 
        iprot.skip(ftype)
19679 
      iprot.readFieldEnd()
19680 
    iprot.readStructEnd()
19681 
 
19682 
  def write(self, oprot):
19683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19685 
      return
19686 
    oprot.writeStructBegin('shiftToWarehouse_args')
19687 
    if self.orderId is not None:
19688 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19689 
      oprot.writeI64(self.orderId)
19690 
      oprot.writeFieldEnd()
19691 
    if self.warehouseId is not None:
19692 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19693 
      oprot.writeI64(self.warehouseId)
19694 
      oprot.writeFieldEnd()
19695 
    oprot.writeFieldStop()
19696 
    oprot.writeStructEnd()
19697 
 
19698 
  def validate(self):
19699 
    return
19700 
 
19701 
 
19702 
  def __repr__(self):
19703 
    L = ['%s=%r' % (key, value)
19704 
      for key, value in self.__dict__.iteritems()]
19705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19706 
 
19707 
  def __eq__(self, other):
19708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19709 
 
19710 
  def __ne__(self, other):
19711 
    return not (self == other)
19712 
 
19713 
class shiftToWarehouse_result:
19714 
  """
19715 
  Attributes:
19716 
   - success
19717 
   - ex
19718 
  """
19719 
 
19720 
  thrift_spec = (
19721 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19722 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19723 
  )
19724 
 
19725 
  def __init__(self, success=None, ex=None,):
19726 
    self.success = success
19727 
    self.ex = ex
19728 
 
19729 
  def read(self, iprot):
19730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19732 
      return
19733 
    iprot.readStructBegin()
19734 
    while True:
19735 
      (fname, ftype, fid) = iprot.readFieldBegin()
19736 
      if ftype == TType.STOP:
19737 
        break
19738 
      if fid == 0:
19739 
        if ftype == TType.STRUCT:
19740 
          self.success = Order()
19741 
          self.success.read(iprot)
19742 
        else:
19743 
          iprot.skip(ftype)
19744 
      elif fid == 1:
19745 
        if ftype == TType.STRUCT:
19746 
          self.ex = TransactionServiceException()
19747 
          self.ex.read(iprot)
19748 
        else:
19749 
          iprot.skip(ftype)
19750 
      else:
19751 
        iprot.skip(ftype)
19752 
      iprot.readFieldEnd()
19753 
    iprot.readStructEnd()
19754 
 
19755 
  def write(self, oprot):
19756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19758 
      return
19759 
    oprot.writeStructBegin('shiftToWarehouse_result')
19760 
    if self.success is not None:
19761 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19762 
      self.success.write(oprot)
19763 
      oprot.writeFieldEnd()
19764 
    if self.ex is not None:
19765 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19766 
      self.ex.write(oprot)
19767 
      oprot.writeFieldEnd()
19768 
    oprot.writeFieldStop()
19769 
    oprot.writeStructEnd()
19770 
 
19771 
  def validate(self):
19772 
    return
19773 
 
19774 
 
19775 
  def __repr__(self):
19776 
    L = ['%s=%r' % (key, value)
19777 
      for key, value in self.__dict__.iteritems()]
19778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19779 
 
19780 
  def __eq__(self, other):
19781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19782 
 
19783 
  def __ne__(self, other):
19784 
    return not (self == other)
3553 chandransh 19785 
 
19786 
class addDelayReason_args:
19787 
  """
19788 
  Attributes:
19789 
   - orderId
19790 
   - delayReason
3986 chandransh 19791 
   - furtherDelay
4647 rajveer 19792 
   - delayReasonText
3553 chandransh 19793 
  """
19794 
 
19795 
  thrift_spec = (
19796 
    None, # 0
19797 
    (1, TType.I64, 'orderId', None, None, ), # 1
19798 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19799 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19800 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19801 
  )
19802 
 
4647 rajveer 19803 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19804 
    self.orderId = orderId
19805 
    self.delayReason = delayReason
3986 chandransh 19806 
    self.furtherDelay = furtherDelay
4647 rajveer 19807 
    self.delayReasonText = delayReasonText
3553 chandransh 19808 
 
19809 
  def read(self, iprot):
19810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19812 
      return
19813 
    iprot.readStructBegin()
19814 
    while True:
19815 
      (fname, ftype, fid) = iprot.readFieldBegin()
19816 
      if ftype == TType.STOP:
19817 
        break
19818 
      if fid == 1:
19819 
        if ftype == TType.I64:
19820 
          self.orderId = iprot.readI64();
19821 
        else:
19822 
          iprot.skip(ftype)
19823 
      elif fid == 2:
19824 
        if ftype == TType.I32:
19825 
          self.delayReason = iprot.readI32();
19826 
        else:
19827 
          iprot.skip(ftype)
3986 chandransh 19828 
      elif fid == 3:
19829 
        if ftype == TType.I64:
19830 
          self.furtherDelay = iprot.readI64();
19831 
        else:
19832 
          iprot.skip(ftype)
4647 rajveer 19833 
      elif fid == 4:
19834 
        if ftype == TType.STRING:
19835 
          self.delayReasonText = iprot.readString();
19836 
        else:
19837 
          iprot.skip(ftype)
3553 chandransh 19838 
      else:
19839 
        iprot.skip(ftype)
19840 
      iprot.readFieldEnd()
19841 
    iprot.readStructEnd()
19842 
 
19843 
  def write(self, oprot):
19844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19846 
      return
19847 
    oprot.writeStructBegin('addDelayReason_args')
19848 
    if self.orderId is not None:
19849 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19850 
      oprot.writeI64(self.orderId)
19851 
      oprot.writeFieldEnd()
19852 
    if self.delayReason is not None:
19853 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19854 
      oprot.writeI32(self.delayReason)
19855 
      oprot.writeFieldEnd()
3986 chandransh 19856 
    if self.furtherDelay is not None:
19857 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19858 
      oprot.writeI64(self.furtherDelay)
19859 
      oprot.writeFieldEnd()
4647 rajveer 19860 
    if self.delayReasonText is not None:
19861 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19862 
      oprot.writeString(self.delayReasonText)
19863 
      oprot.writeFieldEnd()
3553 chandransh 19864 
    oprot.writeFieldStop()
19865 
    oprot.writeStructEnd()
19866 
 
19867 
  def validate(self):
19868 
    return
19869 
 
19870 
 
19871 
  def __repr__(self):
19872 
    L = ['%s=%r' % (key, value)
19873 
      for key, value in self.__dict__.iteritems()]
19874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19875 
 
19876 
  def __eq__(self, other):
19877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19878 
 
19879 
  def __ne__(self, other):
19880 
    return not (self == other)
19881 
 
19882 
class addDelayReason_result:
19883 
  """
19884 
  Attributes:
19885 
   - success
19886 
   - ex
19887 
  """
19888 
 
19889 
  thrift_spec = (
19890 
    (0, TType.BOOL, 'success', None, None, ), # 0
19891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19892 
  )
19893 
 
19894 
  def __init__(self, success=None, ex=None,):
19895 
    self.success = success
19896 
    self.ex = ex
19897 
 
19898 
  def read(self, iprot):
19899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19901 
      return
19902 
    iprot.readStructBegin()
19903 
    while True:
19904 
      (fname, ftype, fid) = iprot.readFieldBegin()
19905 
      if ftype == TType.STOP:
19906 
        break
19907 
      if fid == 0:
19908 
        if ftype == TType.BOOL:
19909 
          self.success = iprot.readBool();
19910 
        else:
19911 
          iprot.skip(ftype)
19912 
      elif fid == 1:
19913 
        if ftype == TType.STRUCT:
19914 
          self.ex = TransactionServiceException()
19915 
          self.ex.read(iprot)
19916 
        else:
19917 
          iprot.skip(ftype)
19918 
      else:
19919 
        iprot.skip(ftype)
19920 
      iprot.readFieldEnd()
19921 
    iprot.readStructEnd()
19922 
 
19923 
  def write(self, oprot):
19924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19926 
      return
19927 
    oprot.writeStructBegin('addDelayReason_result')
19928 
    if self.success is not None:
19929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19930 
      oprot.writeBool(self.success)
19931 
      oprot.writeFieldEnd()
19932 
    if self.ex is not None:
19933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19934 
      self.ex.write(oprot)
19935 
      oprot.writeFieldEnd()
19936 
    oprot.writeFieldStop()
19937 
    oprot.writeStructEnd()
19938 
 
19939 
  def validate(self):
19940 
    return
19941 
 
19942 
 
19943 
  def __repr__(self):
19944 
    L = ['%s=%r' % (key, value)
19945 
      for key, value in self.__dict__.iteritems()]
19946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19947 
 
19948 
  def __eq__(self, other):
19949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19950 
 
19951 
  def __ne__(self, other):
19952 
    return not (self == other)
3956 chandransh 19953 
 
19954 
class reconcileCodCollection_args:
19955 
  """
19956 
  Attributes:
19957 
   - collectedAmountMap
19958 
   - xferBy
19959 
   - xferTxnId
19960 
   - xferDate
19961 
  """
19962 
 
19963 
  thrift_spec = (
19964 
    None, # 0
19965 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19966 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19967 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19968 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19969 
  )
19970 
 
19971 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19972 
    self.collectedAmountMap = collectedAmountMap
19973 
    self.xferBy = xferBy
19974 
    self.xferTxnId = xferTxnId
19975 
    self.xferDate = xferDate
19976 
 
19977 
  def read(self, iprot):
19978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19980 
      return
19981 
    iprot.readStructBegin()
19982 
    while True:
19983 
      (fname, ftype, fid) = iprot.readFieldBegin()
19984 
      if ftype == TType.STOP:
19985 
        break
19986 
      if fid == 1:
19987 
        if ftype == TType.MAP:
19988 
          self.collectedAmountMap = {}
6188 rajveer 19989 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19990 
          for _i457 in xrange(_size453):
19991 
            _key458 = iprot.readString();
19992 
            _val459 = iprot.readDouble();
19993 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19994 
          iprot.readMapEnd()
19995 
        else:
19996 
          iprot.skip(ftype)
19997 
      elif fid == 2:
19998 
        if ftype == TType.STRING:
19999 
          self.xferBy = iprot.readString();
20000 
        else:
20001 
          iprot.skip(ftype)
20002 
      elif fid == 3:
20003 
        if ftype == TType.STRING:
20004 
          self.xferTxnId = iprot.readString();
20005 
        else:
20006 
          iprot.skip(ftype)
20007 
      elif fid == 4:
20008 
        if ftype == TType.I64:
20009 
          self.xferDate = iprot.readI64();
20010 
        else:
20011 
          iprot.skip(ftype)
20012 
      else:
20013 
        iprot.skip(ftype)
20014 
      iprot.readFieldEnd()
20015 
    iprot.readStructEnd()
20016 
 
20017 
  def write(self, oprot):
20018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20020 
      return
20021 
    oprot.writeStructBegin('reconcileCodCollection_args')
20022 
    if self.collectedAmountMap is not None:
20023 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20024 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20025 
      for kiter460,viter461 in self.collectedAmountMap.items():
20026 
        oprot.writeString(kiter460)
20027 
        oprot.writeDouble(viter461)
3956 chandransh 20028 
      oprot.writeMapEnd()
20029 
      oprot.writeFieldEnd()
20030 
    if self.xferBy is not None:
20031 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20032 
      oprot.writeString(self.xferBy)
20033 
      oprot.writeFieldEnd()
20034 
    if self.xferTxnId is not None:
20035 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20036 
      oprot.writeString(self.xferTxnId)
20037 
      oprot.writeFieldEnd()
20038 
    if self.xferDate is not None:
20039 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20040 
      oprot.writeI64(self.xferDate)
20041 
      oprot.writeFieldEnd()
20042 
    oprot.writeFieldStop()
20043 
    oprot.writeStructEnd()
20044 
 
20045 
  def validate(self):
20046 
    return
20047 
 
20048 
 
20049 
  def __repr__(self):
20050 
    L = ['%s=%r' % (key, value)
20051 
      for key, value in self.__dict__.iteritems()]
20052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20053 
 
20054 
  def __eq__(self, other):
20055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20056 
 
20057 
  def __ne__(self, other):
20058 
    return not (self == other)
20059 
 
20060 
class reconcileCodCollection_result:
20061 
  """
20062 
  Attributes:
20063 
   - success
20064 
   - ex
20065 
  """
20066 
 
20067 
  thrift_spec = (
20068 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20069 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20070 
  )
20071 
 
20072 
  def __init__(self, success=None, ex=None,):
20073 
    self.success = success
20074 
    self.ex = ex
20075 
 
20076 
  def read(self, iprot):
20077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20079 
      return
20080 
    iprot.readStructBegin()
20081 
    while True:
20082 
      (fname, ftype, fid) = iprot.readFieldBegin()
20083 
      if ftype == TType.STOP:
20084 
        break
20085 
      if fid == 0:
20086 
        if ftype == TType.MAP:
20087 
          self.success = {}
6188 rajveer 20088 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20089 
          for _i466 in xrange(_size462):
20090 
            _key467 = iprot.readString();
20091 
            _val468 = iprot.readString();
20092 
            self.success[_key467] = _val468
3956 chandransh 20093 
          iprot.readMapEnd()
20094 
        else:
20095 
          iprot.skip(ftype)
20096 
      elif fid == 1:
20097 
        if ftype == TType.STRUCT:
20098 
          self.ex = TransactionServiceException()
20099 
          self.ex.read(iprot)
20100 
        else:
20101 
          iprot.skip(ftype)
20102 
      else:
20103 
        iprot.skip(ftype)
20104 
      iprot.readFieldEnd()
20105 
    iprot.readStructEnd()
20106 
 
20107 
  def write(self, oprot):
20108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20110 
      return
20111 
    oprot.writeStructBegin('reconcileCodCollection_result')
20112 
    if self.success is not None:
20113 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20114 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20115 
      for kiter469,viter470 in self.success.items():
20116 
        oprot.writeString(kiter469)
20117 
        oprot.writeString(viter470)
3956 chandransh 20118 
      oprot.writeMapEnd()
20119 
      oprot.writeFieldEnd()
20120 
    if self.ex is not None:
20121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20122 
      self.ex.write(oprot)
20123 
      oprot.writeFieldEnd()
20124 
    oprot.writeFieldStop()
20125 
    oprot.writeStructEnd()
20126 
 
20127 
  def validate(self):
20128 
    return
20129 
 
20130 
 
20131 
  def __repr__(self):
20132 
    L = ['%s=%r' % (key, value)
20133 
      for key, value in self.__dict__.iteritems()]
20134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20135 
 
20136 
  def __eq__(self, other):
20137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20138 
 
20139 
  def __ne__(self, other):
20140 
    return not (self == other)
4008 mandeep.dh 20141 
 
20142 
class getTransactionsRequiringExtraProcessing_args:
20143 
  """
20144 
  Attributes:
20145 
   - category
20146 
  """
20147 
 
20148 
  thrift_spec = (
20149 
    None, # 0
20150 
    (1, TType.I32, 'category', None, None, ), # 1
20151 
  )
20152 
 
20153 
  def __init__(self, category=None,):
20154 
    self.category = category
20155 
 
20156 
  def read(self, iprot):
20157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20159 
      return
20160 
    iprot.readStructBegin()
20161 
    while True:
20162 
      (fname, ftype, fid) = iprot.readFieldBegin()
20163 
      if ftype == TType.STOP:
20164 
        break
20165 
      if fid == 1:
20166 
        if ftype == TType.I32:
20167 
          self.category = iprot.readI32();
20168 
        else:
20169 
          iprot.skip(ftype)
20170 
      else:
20171 
        iprot.skip(ftype)
20172 
      iprot.readFieldEnd()
20173 
    iprot.readStructEnd()
20174 
 
20175 
  def write(self, oprot):
20176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20178 
      return
20179 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20180 
    if self.category is not None:
20181 
      oprot.writeFieldBegin('category', TType.I32, 1)
20182 
      oprot.writeI32(self.category)
20183 
      oprot.writeFieldEnd()
20184 
    oprot.writeFieldStop()
20185 
    oprot.writeStructEnd()
20186 
 
20187 
  def validate(self):
20188 
    return
20189 
 
20190 
 
20191 
  def __repr__(self):
20192 
    L = ['%s=%r' % (key, value)
20193 
      for key, value in self.__dict__.iteritems()]
20194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20195 
 
20196 
  def __eq__(self, other):
20197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20198 
 
20199 
  def __ne__(self, other):
20200 
    return not (self == other)
20201 
 
20202 
class getTransactionsRequiringExtraProcessing_result:
20203 
  """
20204 
  Attributes:
20205 
   - success
20206 
  """
20207 
 
20208 
  thrift_spec = (
20209 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20210 
  )
20211 
 
20212 
  def __init__(self, success=None,):
20213 
    self.success = success
20214 
 
20215 
  def read(self, iprot):
20216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20218 
      return
20219 
    iprot.readStructBegin()
20220 
    while True:
20221 
      (fname, ftype, fid) = iprot.readFieldBegin()
20222 
      if ftype == TType.STOP:
20223 
        break
20224 
      if fid == 0:
20225 
        if ftype == TType.LIST:
20226 
          self.success = []
6188 rajveer 20227 
          (_etype474, _size471) = iprot.readListBegin()
20228 
          for _i475 in xrange(_size471):
20229 
            _elem476 = iprot.readI64();
20230 
            self.success.append(_elem476)
4008 mandeep.dh 20231 
          iprot.readListEnd()
20232 
        else:
20233 
          iprot.skip(ftype)
20234 
      else:
20235 
        iprot.skip(ftype)
20236 
      iprot.readFieldEnd()
20237 
    iprot.readStructEnd()
20238 
 
20239 
  def write(self, oprot):
20240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20242 
      return
20243 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20244 
    if self.success is not None:
20245 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20246 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20247 
      for iter477 in self.success:
20248 
        oprot.writeI64(iter477)
4008 mandeep.dh 20249 
      oprot.writeListEnd()
20250 
      oprot.writeFieldEnd()
20251 
    oprot.writeFieldStop()
20252 
    oprot.writeStructEnd()
20253 
 
20254 
  def validate(self):
20255 
    return
20256 
 
20257 
 
20258 
  def __repr__(self):
20259 
    L = ['%s=%r' % (key, value)
20260 
      for key, value in self.__dict__.iteritems()]
20261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20262 
 
20263 
  def __eq__(self, other):
20264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20265 
 
20266 
  def __ne__(self, other):
20267 
    return not (self == other)
20268 
 
20269 
class markTransactionAsProcessed_args:
20270 
  """
20271 
  Attributes:
20272 
   - transactionId
20273 
   - category
20274 
  """
20275 
 
20276 
  thrift_spec = (
20277 
    None, # 0
20278 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20279 
    (2, TType.I32, 'category', None, None, ), # 2
20280 
  )
20281 
 
20282 
  def __init__(self, transactionId=None, category=None,):
20283 
    self.transactionId = transactionId
20284 
    self.category = category
20285 
 
20286 
  def read(self, iprot):
20287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20289 
      return
20290 
    iprot.readStructBegin()
20291 
    while True:
20292 
      (fname, ftype, fid) = iprot.readFieldBegin()
20293 
      if ftype == TType.STOP:
20294 
        break
20295 
      if fid == 1:
20296 
        if ftype == TType.I64:
20297 
          self.transactionId = iprot.readI64();
20298 
        else:
20299 
          iprot.skip(ftype)
20300 
      elif fid == 2:
20301 
        if ftype == TType.I32:
20302 
          self.category = iprot.readI32();
20303 
        else:
20304 
          iprot.skip(ftype)
20305 
      else:
20306 
        iprot.skip(ftype)
20307 
      iprot.readFieldEnd()
20308 
    iprot.readStructEnd()
20309 
 
20310 
  def write(self, oprot):
20311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20313 
      return
20314 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20315 
    if self.transactionId is not None:
20316 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20317 
      oprot.writeI64(self.transactionId)
20318 
      oprot.writeFieldEnd()
20319 
    if self.category is not None:
20320 
      oprot.writeFieldBegin('category', TType.I32, 2)
20321 
      oprot.writeI32(self.category)
20322 
      oprot.writeFieldEnd()
20323 
    oprot.writeFieldStop()
20324 
    oprot.writeStructEnd()
20325 
 
20326 
  def validate(self):
20327 
    return
20328 
 
20329 
 
20330 
  def __repr__(self):
20331 
    L = ['%s=%r' % (key, value)
20332 
      for key, value in self.__dict__.iteritems()]
20333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20334 
 
20335 
  def __eq__(self, other):
20336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20337 
 
20338 
  def __ne__(self, other):
20339 
    return not (self == other)
20340 
 
20341 
class markTransactionAsProcessed_result:
20342 
 
20343 
  thrift_spec = (
20344 
  )
20345 
 
20346 
  def read(self, iprot):
20347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20349 
      return
20350 
    iprot.readStructBegin()
20351 
    while True:
20352 
      (fname, ftype, fid) = iprot.readFieldBegin()
20353 
      if ftype == TType.STOP:
20354 
        break
20355 
      else:
20356 
        iprot.skip(ftype)
20357 
      iprot.readFieldEnd()
20358 
    iprot.readStructEnd()
20359 
 
20360 
  def write(self, oprot):
20361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20363 
      return
20364 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20365 
    oprot.writeFieldStop()
20366 
    oprot.writeStructEnd()
20367 
 
20368 
  def validate(self):
20369 
    return
20370 
 
20371 
 
20372 
  def __repr__(self):
20373 
    L = ['%s=%r' % (key, value)
20374 
      for key, value in self.__dict__.iteritems()]
20375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20376 
 
20377 
  def __eq__(self, other):
20378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20379 
 
20380 
  def __ne__(self, other):
20381 
    return not (self == other)
4018 chandransh 20382 
 
20383 
class getItemWiseRiskyOrdersCount_args:
20384 
 
20385 
  thrift_spec = (
20386 
  )
20387 
 
20388 
  def read(self, iprot):
20389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20391 
      return
20392 
    iprot.readStructBegin()
20393 
    while True:
20394 
      (fname, ftype, fid) = iprot.readFieldBegin()
20395 
      if ftype == TType.STOP:
20396 
        break
20397 
      else:
20398 
        iprot.skip(ftype)
20399 
      iprot.readFieldEnd()
20400 
    iprot.readStructEnd()
20401 
 
20402 
  def write(self, oprot):
20403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20405 
      return
20406 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20407 
    oprot.writeFieldStop()
20408 
    oprot.writeStructEnd()
20409 
 
20410 
  def validate(self):
20411 
    return
20412 
 
20413 
 
20414 
  def __repr__(self):
20415 
    L = ['%s=%r' % (key, value)
20416 
      for key, value in self.__dict__.iteritems()]
20417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20418 
 
20419 
  def __eq__(self, other):
20420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20421 
 
20422 
  def __ne__(self, other):
20423 
    return not (self == other)
20424 
 
20425 
class getItemWiseRiskyOrdersCount_result:
20426 
  """
20427 
  Attributes:
20428 
   - success
20429 
  """
20430 
 
20431 
  thrift_spec = (
20432 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20433 
  )
20434 
 
20435 
  def __init__(self, success=None,):
20436 
    self.success = success
20437 
 
20438 
  def read(self, iprot):
20439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20441 
      return
20442 
    iprot.readStructBegin()
20443 
    while True:
20444 
      (fname, ftype, fid) = iprot.readFieldBegin()
20445 
      if ftype == TType.STOP:
20446 
        break
20447 
      if fid == 0:
20448 
        if ftype == TType.MAP:
20449 
          self.success = {}
6188 rajveer 20450 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20451 
          for _i482 in xrange(_size478):
20452 
            _key483 = iprot.readI64();
20453 
            _val484 = iprot.readI64();
20454 
            self.success[_key483] = _val484
4018 chandransh 20455 
          iprot.readMapEnd()
20456 
        else:
20457 
          iprot.skip(ftype)
20458 
      else:
20459 
        iprot.skip(ftype)
20460 
      iprot.readFieldEnd()
20461 
    iprot.readStructEnd()
20462 
 
20463 
  def write(self, oprot):
20464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20466 
      return
20467 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20468 
    if self.success is not None:
20469 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20470 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20471 
      for kiter485,viter486 in self.success.items():
20472 
        oprot.writeI64(kiter485)
20473 
        oprot.writeI64(viter486)
4018 chandransh 20474 
      oprot.writeMapEnd()
20475 
      oprot.writeFieldEnd()
20476 
    oprot.writeFieldStop()
20477 
    oprot.writeStructEnd()
20478 
 
20479 
  def validate(self):
20480 
    return
20481 
 
20482 
 
20483 
  def __repr__(self):
20484 
    L = ['%s=%r' % (key, value)
20485 
      for key, value in self.__dict__.iteritems()]
20486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20487 
 
20488 
  def __eq__(self, other):
20489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20490 
 
20491 
  def __ne__(self, other):
20492 
    return not (self == other)
4247 rajveer 20493 
 
4295 varun.gupt 20494 
class getOrdersForItemIds_args:
20495 
  """
20496 
  Attributes:
20497 
   - itemIds
20498 
  """
20499 
 
20500 
  thrift_spec = (
20501 
    None, # 0
20502 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20503 
  )
20504 
 
20505 
  def __init__(self, itemIds=None,):
20506 
    self.itemIds = itemIds
20507 
 
20508 
  def read(self, iprot):
20509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20511 
      return
20512 
    iprot.readStructBegin()
20513 
    while True:
20514 
      (fname, ftype, fid) = iprot.readFieldBegin()
20515 
      if ftype == TType.STOP:
20516 
        break
20517 
      if fid == 1:
20518 
        if ftype == TType.LIST:
20519 
          self.itemIds = []
6188 rajveer 20520 
          (_etype490, _size487) = iprot.readListBegin()
20521 
          for _i491 in xrange(_size487):
20522 
            _elem492 = iprot.readI64();
20523 
            self.itemIds.append(_elem492)
4295 varun.gupt 20524 
          iprot.readListEnd()
20525 
        else:
20526 
          iprot.skip(ftype)
20527 
      else:
20528 
        iprot.skip(ftype)
20529 
      iprot.readFieldEnd()
20530 
    iprot.readStructEnd()
20531 
 
20532 
  def write(self, oprot):
20533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20535 
      return
20536 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20537 
    if self.itemIds is not None:
20538 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20539 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20540 
      for iter493 in self.itemIds:
20541 
        oprot.writeI64(iter493)
4295 varun.gupt 20542 
      oprot.writeListEnd()
20543 
      oprot.writeFieldEnd()
20544 
    oprot.writeFieldStop()
20545 
    oprot.writeStructEnd()
20546 
 
20547 
  def validate(self):
20548 
    return
20549 
 
20550 
 
20551 
  def __repr__(self):
20552 
    L = ['%s=%r' % (key, value)
20553 
      for key, value in self.__dict__.iteritems()]
20554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20555 
 
20556 
  def __eq__(self, other):
20557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20558 
 
20559 
  def __ne__(self, other):
20560 
    return not (self == other)
20561 
 
20562 
class getOrdersForItemIds_result:
20563 
  """
20564 
  Attributes:
20565 
   - success
20566 
  """
20567 
 
20568 
  thrift_spec = (
20569 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20570 
  )
20571 
 
20572 
  def __init__(self, success=None,):
20573 
    self.success = success
20574 
 
20575 
  def read(self, iprot):
20576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20578 
      return
20579 
    iprot.readStructBegin()
20580 
    while True:
20581 
      (fname, ftype, fid) = iprot.readFieldBegin()
20582 
      if ftype == TType.STOP:
20583 
        break
20584 
      if fid == 0:
20585 
        if ftype == TType.LIST:
20586 
          self.success = []
6188 rajveer 20587 
          (_etype497, _size494) = iprot.readListBegin()
20588 
          for _i498 in xrange(_size494):
20589 
            _elem499 = Order()
20590 
            _elem499.read(iprot)
20591 
            self.success.append(_elem499)
4295 varun.gupt 20592 
          iprot.readListEnd()
20593 
        else:
20594 
          iprot.skip(ftype)
20595 
      else:
20596 
        iprot.skip(ftype)
20597 
      iprot.readFieldEnd()
20598 
    iprot.readStructEnd()
20599 
 
20600 
  def write(self, oprot):
20601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20603 
      return
20604 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20605 
    if self.success is not None:
20606 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20607 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20608 
      for iter500 in self.success:
20609 
        iter500.write(oprot)
4295 varun.gupt 20610 
      oprot.writeListEnd()
20611 
      oprot.writeFieldEnd()
20612 
    oprot.writeFieldStop()
20613 
    oprot.writeStructEnd()
20614 
 
20615 
  def validate(self):
20616 
    return
20617 
 
20618 
 
20619 
  def __repr__(self):
20620 
    L = ['%s=%r' % (key, value)
20621 
      for key, value in self.__dict__.iteritems()]
20622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20623 
 
20624 
  def __eq__(self, other):
20625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20626 
 
20627 
  def __ne__(self, other):
20628 
    return not (self == other)
20629 
 
4247 rajveer 20630 
class markOrderCancellationRequestReceived_args:
20631 
  """
20632 
  Attributes:
20633 
   - orderId
20634 
  """
20635 
 
20636 
  thrift_spec = (
20637 
    None, # 0
20638 
    (1, TType.I64, 'orderId', None, None, ), # 1
20639 
  )
20640 
 
20641 
  def __init__(self, orderId=None,):
20642 
    self.orderId = orderId
20643 
 
20644 
  def read(self, iprot):
20645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20647 
      return
20648 
    iprot.readStructBegin()
20649 
    while True:
20650 
      (fname, ftype, fid) = iprot.readFieldBegin()
20651 
      if ftype == TType.STOP:
20652 
        break
20653 
      if fid == 1:
20654 
        if ftype == TType.I64:
20655 
          self.orderId = iprot.readI64();
20656 
        else:
20657 
          iprot.skip(ftype)
20658 
      else:
20659 
        iprot.skip(ftype)
20660 
      iprot.readFieldEnd()
20661 
    iprot.readStructEnd()
20662 
 
20663 
  def write(self, oprot):
20664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20666 
      return
20667 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20668 
    if self.orderId is not None:
20669 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20670 
      oprot.writeI64(self.orderId)
20671 
      oprot.writeFieldEnd()
20672 
    oprot.writeFieldStop()
20673 
    oprot.writeStructEnd()
20674 
 
20675 
  def validate(self):
20676 
    return
20677 
 
20678 
 
20679 
  def __repr__(self):
20680 
    L = ['%s=%r' % (key, value)
20681 
      for key, value in self.__dict__.iteritems()]
20682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20683 
 
20684 
  def __eq__(self, other):
20685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20686 
 
20687 
  def __ne__(self, other):
20688 
    return not (self == other)
20689 
 
20690 
class markOrderCancellationRequestReceived_result:
20691 
  """
20692 
  Attributes:
20693 
   - ex
20694 
  """
20695 
 
20696 
  thrift_spec = (
20697 
    None, # 0
20698 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20699 
  )
20700 
 
20701 
  def __init__(self, ex=None,):
20702 
    self.ex = ex
20703 
 
20704 
  def read(self, iprot):
20705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20707 
      return
20708 
    iprot.readStructBegin()
20709 
    while True:
20710 
      (fname, ftype, fid) = iprot.readFieldBegin()
20711 
      if ftype == TType.STOP:
20712 
        break
20713 
      if fid == 1:
20714 
        if ftype == TType.STRUCT:
20715 
          self.ex = TransactionServiceException()
20716 
          self.ex.read(iprot)
20717 
        else:
20718 
          iprot.skip(ftype)
20719 
      else:
20720 
        iprot.skip(ftype)
20721 
      iprot.readFieldEnd()
20722 
    iprot.readStructEnd()
20723 
 
20724 
  def write(self, oprot):
20725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20727 
      return
20728 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20729 
    if self.ex is not None:
20730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20731 
      self.ex.write(oprot)
20732 
      oprot.writeFieldEnd()
20733 
    oprot.writeFieldStop()
20734 
    oprot.writeStructEnd()
20735 
 
20736 
  def validate(self):
20737 
    return
20738 
 
20739 
 
20740 
  def __repr__(self):
20741 
    L = ['%s=%r' % (key, value)
20742 
      for key, value in self.__dict__.iteritems()]
20743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20744 
 
20745 
  def __eq__(self, other):
20746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20747 
 
20748 
  def __ne__(self, other):
20749 
    return not (self == other)
20750 
 
20751 
class markOrderCancellationRequestConfirmed_args:
20752 
  """
20753 
  Attributes:
20754 
   - orderId
20755 
  """
20756 
 
20757 
  thrift_spec = (
20758 
    None, # 0
20759 
    (1, TType.I64, 'orderId', None, None, ), # 1
20760 
  )
20761 
 
20762 
  def __init__(self, orderId=None,):
20763 
    self.orderId = orderId
20764 
 
20765 
  def read(self, iprot):
20766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20768 
      return
20769 
    iprot.readStructBegin()
20770 
    while True:
20771 
      (fname, ftype, fid) = iprot.readFieldBegin()
20772 
      if ftype == TType.STOP:
20773 
        break
20774 
      if fid == 1:
20775 
        if ftype == TType.I64:
20776 
          self.orderId = iprot.readI64();
20777 
        else:
20778 
          iprot.skip(ftype)
20779 
      else:
20780 
        iprot.skip(ftype)
20781 
      iprot.readFieldEnd()
20782 
    iprot.readStructEnd()
20783 
 
20784 
  def write(self, oprot):
20785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20787 
      return
20788 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20789 
    if self.orderId is not None:
20790 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20791 
      oprot.writeI64(self.orderId)
20792 
      oprot.writeFieldEnd()
20793 
    oprot.writeFieldStop()
20794 
    oprot.writeStructEnd()
20795 
 
20796 
  def validate(self):
20797 
    return
20798 
 
20799 
 
20800 
  def __repr__(self):
20801 
    L = ['%s=%r' % (key, value)
20802 
      for key, value in self.__dict__.iteritems()]
20803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20804 
 
20805 
  def __eq__(self, other):
20806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20807 
 
20808 
  def __ne__(self, other):
20809 
    return not (self == other)
20810 
 
20811 
class markOrderCancellationRequestConfirmed_result:
20812 
  """
20813 
  Attributes:
20814 
   - ex
20815 
  """
20816 
 
20817 
  thrift_spec = (
20818 
    None, # 0
20819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20820 
  )
20821 
 
20822 
  def __init__(self, ex=None,):
20823 
    self.ex = ex
20824 
 
20825 
  def read(self, iprot):
20826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20828 
      return
20829 
    iprot.readStructBegin()
20830 
    while True:
20831 
      (fname, ftype, fid) = iprot.readFieldBegin()
20832 
      if ftype == TType.STOP:
20833 
        break
20834 
      if fid == 1:
20835 
        if ftype == TType.STRUCT:
20836 
          self.ex = TransactionServiceException()
20837 
          self.ex.read(iprot)
20838 
        else:
20839 
          iprot.skip(ftype)
20840 
      else:
20841 
        iprot.skip(ftype)
20842 
      iprot.readFieldEnd()
20843 
    iprot.readStructEnd()
20844 
 
20845 
  def write(self, oprot):
20846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20848 
      return
20849 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20850 
    if self.ex is not None:
20851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20852 
      self.ex.write(oprot)
20853 
      oprot.writeFieldEnd()
20854 
    oprot.writeFieldStop()
20855 
    oprot.writeStructEnd()
20856 
 
20857 
  def validate(self):
20858 
    return
20859 
 
20860 
 
20861 
  def __repr__(self):
20862 
    L = ['%s=%r' % (key, value)
20863 
      for key, value in self.__dict__.iteritems()]
20864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20865 
 
20866 
  def __eq__(self, other):
20867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20868 
 
20869 
  def __ne__(self, other):
20870 
    return not (self == other)
20871 
 
20872 
class markOrderCancellationRequestDenied_args:
20873 
  """
20874 
  Attributes:
20875 
   - orderId
20876 
  """
20877 
 
20878 
  thrift_spec = (
20879 
    None, # 0
20880 
    (1, TType.I64, 'orderId', None, None, ), # 1
20881 
  )
20882 
 
20883 
  def __init__(self, orderId=None,):
20884 
    self.orderId = orderId
20885 
 
20886 
  def read(self, iprot):
20887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20889 
      return
20890 
    iprot.readStructBegin()
20891 
    while True:
20892 
      (fname, ftype, fid) = iprot.readFieldBegin()
20893 
      if ftype == TType.STOP:
20894 
        break
20895 
      if fid == 1:
20896 
        if ftype == TType.I64:
20897 
          self.orderId = iprot.readI64();
20898 
        else:
20899 
          iprot.skip(ftype)
20900 
      else:
20901 
        iprot.skip(ftype)
20902 
      iprot.readFieldEnd()
20903 
    iprot.readStructEnd()
20904 
 
20905 
  def write(self, oprot):
20906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20908 
      return
20909 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20910 
    if self.orderId is not None:
20911 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20912 
      oprot.writeI64(self.orderId)
20913 
      oprot.writeFieldEnd()
20914 
    oprot.writeFieldStop()
20915 
    oprot.writeStructEnd()
20916 
 
20917 
  def validate(self):
20918 
    return
20919 
 
20920 
 
20921 
  def __repr__(self):
20922 
    L = ['%s=%r' % (key, value)
20923 
      for key, value in self.__dict__.iteritems()]
20924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20925 
 
20926 
  def __eq__(self, other):
20927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20928 
 
20929 
  def __ne__(self, other):
20930 
    return not (self == other)
20931 
 
20932 
class markOrderCancellationRequestDenied_result:
20933 
  """
20934 
  Attributes:
20935 
   - ex
20936 
  """
20937 
 
20938 
  thrift_spec = (
20939 
    None, # 0
20940 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20941 
  )
20942 
 
20943 
  def __init__(self, ex=None,):
20944 
    self.ex = ex
20945 
 
20946 
  def read(self, iprot):
20947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20949 
      return
20950 
    iprot.readStructBegin()
20951 
    while True:
20952 
      (fname, ftype, fid) = iprot.readFieldBegin()
20953 
      if ftype == TType.STOP:
20954 
        break
20955 
      if fid == 1:
20956 
        if ftype == TType.STRUCT:
20957 
          self.ex = TransactionServiceException()
20958 
          self.ex.read(iprot)
20959 
        else:
20960 
          iprot.skip(ftype)
20961 
      else:
20962 
        iprot.skip(ftype)
20963 
      iprot.readFieldEnd()
20964 
    iprot.readStructEnd()
20965 
 
20966 
  def write(self, oprot):
20967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20969 
      return
20970 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20971 
    if self.ex is not None:
20972 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20973 
      self.ex.write(oprot)
20974 
      oprot.writeFieldEnd()
20975 
    oprot.writeFieldStop()
20976 
    oprot.writeStructEnd()
20977 
 
20978 
  def validate(self):
20979 
    return
20980 
 
20981 
 
20982 
  def __repr__(self):
20983 
    L = ['%s=%r' % (key, value)
20984 
      for key, value in self.__dict__.iteritems()]
20985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20986 
 
20987 
  def __eq__(self, other):
20988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20989 
 
20990 
  def __ne__(self, other):
20991 
    return not (self == other)
20992 
 
4258 rajveer 20993 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20994 
  """
20995 
  Attributes:
4258 rajveer 20996 
   - transactionId
4247 rajveer 20997 
  """
20998 
 
20999 
  thrift_spec = (
21000 
    None, # 0
4258 rajveer 21001 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21002 
  )
21003 
 
4258 rajveer 21004 
  def __init__(self, transactionId=None,):
21005 
    self.transactionId = transactionId
4247 rajveer 21006 
 
21007 
  def read(self, iprot):
21008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21010 
      return
21011 
    iprot.readStructBegin()
21012 
    while True:
21013 
      (fname, ftype, fid) = iprot.readFieldBegin()
21014 
      if ftype == TType.STOP:
21015 
        break
21016 
      if fid == 1:
21017 
        if ftype == TType.I64:
4258 rajveer 21018 
          self.transactionId = iprot.readI64();
4247 rajveer 21019 
        else:
21020 
          iprot.skip(ftype)
21021 
      else:
21022 
        iprot.skip(ftype)
21023 
      iprot.readFieldEnd()
21024 
    iprot.readStructEnd()
21025 
 
21026 
  def write(self, oprot):
21027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21029 
      return
4258 rajveer 21030 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21031 
    if self.transactionId is not None:
21032 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21033 
      oprot.writeI64(self.transactionId)
4247 rajveer 21034 
      oprot.writeFieldEnd()
21035 
    oprot.writeFieldStop()
21036 
    oprot.writeStructEnd()
21037 
 
21038 
  def validate(self):
21039 
    return
21040 
 
21041 
 
21042 
  def __repr__(self):
21043 
    L = ['%s=%r' % (key, value)
21044 
      for key, value in self.__dict__.iteritems()]
21045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21046 
 
21047 
  def __eq__(self, other):
21048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21049 
 
21050 
  def __ne__(self, other):
21051 
    return not (self == other)
21052 
 
4258 rajveer 21053 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21054 
  """
21055 
  Attributes:
21056 
   - ex
21057 
  """
21058 
 
21059 
  thrift_spec = (
21060 
    None, # 0
21061 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21062 
  )
21063 
 
21064 
  def __init__(self, ex=None,):
21065 
    self.ex = ex
21066 
 
21067 
  def read(self, iprot):
21068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21070 
      return
21071 
    iprot.readStructBegin()
21072 
    while True:
21073 
      (fname, ftype, fid) = iprot.readFieldBegin()
21074 
      if ftype == TType.STOP:
21075 
        break
21076 
      if fid == 1:
21077 
        if ftype == TType.STRUCT:
21078 
          self.ex = TransactionServiceException()
21079 
          self.ex.read(iprot)
21080 
        else:
21081 
          iprot.skip(ftype)
21082 
      else:
21083 
        iprot.skip(ftype)
21084 
      iprot.readFieldEnd()
21085 
    iprot.readStructEnd()
21086 
 
21087 
  def write(self, oprot):
21088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21090 
      return
4258 rajveer 21091 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21092 
    if self.ex is not None:
21093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21094 
      self.ex.write(oprot)
21095 
      oprot.writeFieldEnd()
21096 
    oprot.writeFieldStop()
21097 
    oprot.writeStructEnd()
21098 
 
21099 
  def validate(self):
21100 
    return
21101 
 
21102 
 
21103 
  def __repr__(self):
21104 
    L = ['%s=%r' % (key, value)
21105 
      for key, value in self.__dict__.iteritems()]
21106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21107 
 
21108 
  def __eq__(self, other):
21109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21110 
 
21111 
  def __ne__(self, other):
21112 
    return not (self == other)
4259 anupam.sin 21113 
 
21114 
class refundTransaction_args:
21115 
  """
21116 
  Attributes:
21117 
   - transactionId
21118 
   - refundedBy
21119 
   - reason
21120 
  """
21121 
 
21122 
  thrift_spec = (
21123 
    None, # 0
21124 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21125 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21126 
    (3, TType.STRING, 'reason', None, None, ), # 3
21127 
  )
21128 
 
21129 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21130 
    self.transactionId = transactionId
21131 
    self.refundedBy = refundedBy
21132 
    self.reason = reason
21133 
 
21134 
  def read(self, iprot):
21135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21137 
      return
21138 
    iprot.readStructBegin()
21139 
    while True:
21140 
      (fname, ftype, fid) = iprot.readFieldBegin()
21141 
      if ftype == TType.STOP:
21142 
        break
21143 
      if fid == 1:
21144 
        if ftype == TType.I64:
21145 
          self.transactionId = iprot.readI64();
21146 
        else:
21147 
          iprot.skip(ftype)
21148 
      elif fid == 2:
21149 
        if ftype == TType.STRING:
21150 
          self.refundedBy = iprot.readString();
21151 
        else:
21152 
          iprot.skip(ftype)
21153 
      elif fid == 3:
21154 
        if ftype == TType.STRING:
21155 
          self.reason = iprot.readString();
21156 
        else:
21157 
          iprot.skip(ftype)
21158 
      else:
21159 
        iprot.skip(ftype)
21160 
      iprot.readFieldEnd()
21161 
    iprot.readStructEnd()
21162 
 
21163 
  def write(self, oprot):
21164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21166 
      return
21167 
    oprot.writeStructBegin('refundTransaction_args')
21168 
    if self.transactionId is not None:
21169 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21170 
      oprot.writeI64(self.transactionId)
21171 
      oprot.writeFieldEnd()
21172 
    if self.refundedBy is not None:
21173 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21174 
      oprot.writeString(self.refundedBy)
21175 
      oprot.writeFieldEnd()
21176 
    if self.reason is not None:
21177 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21178 
      oprot.writeString(self.reason)
21179 
      oprot.writeFieldEnd()
21180 
    oprot.writeFieldStop()
21181 
    oprot.writeStructEnd()
21182 
 
21183 
  def validate(self):
21184 
    return
21185 
 
21186 
 
21187 
  def __repr__(self):
21188 
    L = ['%s=%r' % (key, value)
21189 
      for key, value in self.__dict__.iteritems()]
21190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21191 
 
21192 
  def __eq__(self, other):
21193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21194 
 
21195 
  def __ne__(self, other):
21196 
    return not (self == other)
21197 
 
21198 
class refundTransaction_result:
21199 
  """
21200 
  Attributes:
21201 
   - ex
21202 
  """
21203 
 
21204 
  thrift_spec = (
21205 
    None, # 0
21206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21207 
  )
21208 
 
21209 
  def __init__(self, ex=None,):
21210 
    self.ex = ex
21211 
 
21212 
  def read(self, iprot):
21213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21215 
      return
21216 
    iprot.readStructBegin()
21217 
    while True:
21218 
      (fname, ftype, fid) = iprot.readFieldBegin()
21219 
      if ftype == TType.STOP:
21220 
        break
21221 
      if fid == 1:
21222 
        if ftype == TType.STRUCT:
21223 
          self.ex = TransactionServiceException()
21224 
          self.ex.read(iprot)
21225 
        else:
21226 
          iprot.skip(ftype)
21227 
      else:
21228 
        iprot.skip(ftype)
21229 
      iprot.readFieldEnd()
21230 
    iprot.readStructEnd()
21231 
 
21232 
  def write(self, oprot):
21233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21235 
      return
21236 
    oprot.writeStructBegin('refundTransaction_result')
21237 
    if self.ex is not None:
21238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21239 
      self.ex.write(oprot)
21240 
      oprot.writeFieldEnd()
21241 
    oprot.writeFieldStop()
21242 
    oprot.writeStructEnd()
21243 
 
21244 
  def validate(self):
21245 
    return
21246 
 
21247 
 
21248 
  def __repr__(self):
21249 
    L = ['%s=%r' % (key, value)
21250 
      for key, value in self.__dict__.iteritems()]
21251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21252 
 
21253 
  def __eq__(self, other):
21254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21255 
 
21256 
  def __ne__(self, other):
21257 
    return not (self == other)
4285 rajveer 21258 
 
4324 mandeep.dh 21259 
class updateShipmentAddress_args:
21260 
  """
21261 
  Attributes:
21262 
   - orderId
21263 
   - addressId
21264 
  """
21265 
 
21266 
  thrift_spec = (
21267 
    None, # 0
21268 
    (1, TType.I64, 'orderId', None, None, ), # 1
21269 
    (2, TType.I64, 'addressId', None, None, ), # 2
21270 
  )
21271 
 
21272 
  def __init__(self, orderId=None, addressId=None,):
21273 
    self.orderId = orderId
21274 
    self.addressId = addressId
21275 
 
21276 
  def read(self, iprot):
21277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21279 
      return
21280 
    iprot.readStructBegin()
21281 
    while True:
21282 
      (fname, ftype, fid) = iprot.readFieldBegin()
21283 
      if ftype == TType.STOP:
21284 
        break
21285 
      if fid == 1:
21286 
        if ftype == TType.I64:
21287 
          self.orderId = iprot.readI64();
21288 
        else:
21289 
          iprot.skip(ftype)
21290 
      elif fid == 2:
21291 
        if ftype == TType.I64:
21292 
          self.addressId = iprot.readI64();
21293 
        else:
21294 
          iprot.skip(ftype)
21295 
      else:
21296 
        iprot.skip(ftype)
21297 
      iprot.readFieldEnd()
21298 
    iprot.readStructEnd()
21299 
 
21300 
  def write(self, oprot):
21301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21303 
      return
21304 
    oprot.writeStructBegin('updateShipmentAddress_args')
21305 
    if self.orderId is not None:
21306 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21307 
      oprot.writeI64(self.orderId)
21308 
      oprot.writeFieldEnd()
21309 
    if self.addressId is not None:
21310 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21311 
      oprot.writeI64(self.addressId)
21312 
      oprot.writeFieldEnd()
21313 
    oprot.writeFieldStop()
21314 
    oprot.writeStructEnd()
21315 
 
21316 
  def validate(self):
21317 
    return
21318 
 
21319 
 
21320 
  def __repr__(self):
21321 
    L = ['%s=%r' % (key, value)
21322 
      for key, value in self.__dict__.iteritems()]
21323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21324 
 
21325 
  def __eq__(self, other):
21326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21327 
 
21328 
  def __ne__(self, other):
21329 
    return not (self == other)
21330 
 
21331 
class updateShipmentAddress_result:
21332 
  """
21333 
  Attributes:
21334 
   - ex
21335 
  """
21336 
 
21337 
  thrift_spec = (
21338 
    None, # 0
21339 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21340 
  )
21341 
 
21342 
  def __init__(self, ex=None,):
21343 
    self.ex = ex
21344 
 
21345 
  def read(self, iprot):
21346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21348 
      return
21349 
    iprot.readStructBegin()
21350 
    while True:
21351 
      (fname, ftype, fid) = iprot.readFieldBegin()
21352 
      if ftype == TType.STOP:
21353 
        break
21354 
      if fid == 1:
21355 
        if ftype == TType.STRUCT:
21356 
          self.ex = TransactionServiceException()
21357 
          self.ex.read(iprot)
21358 
        else:
21359 
          iprot.skip(ftype)
21360 
      else:
21361 
        iprot.skip(ftype)
21362 
      iprot.readFieldEnd()
21363 
    iprot.readStructEnd()
21364 
 
21365 
  def write(self, oprot):
21366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21368 
      return
21369 
    oprot.writeStructBegin('updateShipmentAddress_result')
21370 
    if self.ex is not None:
21371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21372 
      self.ex.write(oprot)
21373 
      oprot.writeFieldEnd()
21374 
    oprot.writeFieldStop()
21375 
    oprot.writeStructEnd()
21376 
 
21377 
  def validate(self):
21378 
    return
21379 
 
21380 
 
21381 
  def __repr__(self):
21382 
    L = ['%s=%r' % (key, value)
21383 
      for key, value in self.__dict__.iteritems()]
21384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21385 
 
21386 
  def __eq__(self, other):
21387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21388 
 
21389 
  def __ne__(self, other):
21390 
    return not (self == other)
21391 
 
4285 rajveer 21392 
class acceptOrdersForItemId_args:
21393 
  """
21394 
  Attributes:
21395 
   - itemId
21396 
   - inventory
21397 
  """
21398 
 
21399 
  thrift_spec = (
21400 
    None, # 0
21401 
    (1, TType.I64, 'itemId', None, None, ), # 1
21402 
    (2, TType.I64, 'inventory', None, None, ), # 2
21403 
  )
21404 
 
21405 
  def __init__(self, itemId=None, inventory=None,):
21406 
    self.itemId = itemId
21407 
    self.inventory = inventory
21408 
 
21409 
  def read(self, iprot):
21410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21412 
      return
21413 
    iprot.readStructBegin()
21414 
    while True:
21415 
      (fname, ftype, fid) = iprot.readFieldBegin()
21416 
      if ftype == TType.STOP:
21417 
        break
21418 
      if fid == 1:
21419 
        if ftype == TType.I64:
21420 
          self.itemId = iprot.readI64();
21421 
        else:
21422 
          iprot.skip(ftype)
21423 
      elif fid == 2:
21424 
        if ftype == TType.I64:
21425 
          self.inventory = iprot.readI64();
21426 
        else:
21427 
          iprot.skip(ftype)
21428 
      else:
21429 
        iprot.skip(ftype)
21430 
      iprot.readFieldEnd()
21431 
    iprot.readStructEnd()
21432 
 
21433 
  def write(self, oprot):
21434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21436 
      return
21437 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21438 
    if self.itemId is not None:
21439 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21440 
      oprot.writeI64(self.itemId)
21441 
      oprot.writeFieldEnd()
21442 
    if self.inventory is not None:
21443 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21444 
      oprot.writeI64(self.inventory)
21445 
      oprot.writeFieldEnd()
21446 
    oprot.writeFieldStop()
21447 
    oprot.writeStructEnd()
21448 
 
21449 
  def validate(self):
21450 
    return
21451 
 
21452 
 
21453 
  def __repr__(self):
21454 
    L = ['%s=%r' % (key, value)
21455 
      for key, value in self.__dict__.iteritems()]
21456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21457 
 
21458 
  def __eq__(self, other):
21459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21460 
 
21461 
  def __ne__(self, other):
21462 
    return not (self == other)
21463 
 
21464 
class acceptOrdersForItemId_result:
21465 
  """
21466 
  Attributes:
21467 
   - success
21468 
   - ex
21469 
  """
21470 
 
21471 
  thrift_spec = (
21472 
    (0, TType.BOOL, 'success', None, None, ), # 0
21473 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21474 
  )
21475 
 
21476 
  def __init__(self, success=None, ex=None,):
21477 
    self.success = success
21478 
    self.ex = ex
21479 
 
21480 
  def read(self, iprot):
21481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21483 
      return
21484 
    iprot.readStructBegin()
21485 
    while True:
21486 
      (fname, ftype, fid) = iprot.readFieldBegin()
21487 
      if ftype == TType.STOP:
21488 
        break
21489 
      if fid == 0:
21490 
        if ftype == TType.BOOL:
21491 
          self.success = iprot.readBool();
21492 
        else:
21493 
          iprot.skip(ftype)
21494 
      elif fid == 1:
21495 
        if ftype == TType.STRUCT:
21496 
          self.ex = TransactionServiceException()
21497 
          self.ex.read(iprot)
21498 
        else:
21499 
          iprot.skip(ftype)
21500 
      else:
21501 
        iprot.skip(ftype)
21502 
      iprot.readFieldEnd()
21503 
    iprot.readStructEnd()
21504 
 
21505 
  def write(self, oprot):
21506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21508 
      return
21509 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21510 
    if self.success is not None:
21511 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21512 
      oprot.writeBool(self.success)
21513 
      oprot.writeFieldEnd()
21514 
    if self.ex is not None:
21515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21516 
      self.ex.write(oprot)
21517 
      oprot.writeFieldEnd()
21518 
    oprot.writeFieldStop()
21519 
    oprot.writeStructEnd()
21520 
 
21521 
  def validate(self):
21522 
    return
21523 
 
21524 
 
21525 
  def __repr__(self):
21526 
    L = ['%s=%r' % (key, value)
21527 
      for key, value in self.__dict__.iteritems()]
21528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21529 
 
21530 
  def __eq__(self, other):
21531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21532 
 
21533 
  def __ne__(self, other):
21534 
    return not (self == other)
4303 rajveer 21535 
 
21536 
class markOrdersAsPORaised_args:
21537 
  """
21538 
  Attributes:
21539 
   - vendorId
21540 
   - itemId
21541 
   - quantity
21542 
   - estimate
4369 rajveer 21543 
   - isReminder
4303 rajveer 21544 
  """
21545 
 
21546 
  thrift_spec = (
21547 
    None, # 0
21548 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21549 
    (2, TType.I64, 'itemId', None, None, ), # 2
21550 
    (3, TType.I64, 'quantity', None, None, ), # 3
21551 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21552 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21553 
  )
21554 
 
4369 rajveer 21555 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21556 
    self.vendorId = vendorId
21557 
    self.itemId = itemId
21558 
    self.quantity = quantity
21559 
    self.estimate = estimate
4369 rajveer 21560 
    self.isReminder = isReminder
4303 rajveer 21561 
 
21562 
  def read(self, iprot):
21563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21565 
      return
21566 
    iprot.readStructBegin()
21567 
    while True:
21568 
      (fname, ftype, fid) = iprot.readFieldBegin()
21569 
      if ftype == TType.STOP:
21570 
        break
21571 
      if fid == 1:
21572 
        if ftype == TType.I64:
21573 
          self.vendorId = iprot.readI64();
21574 
        else:
21575 
          iprot.skip(ftype)
21576 
      elif fid == 2:
21577 
        if ftype == TType.I64:
21578 
          self.itemId = iprot.readI64();
21579 
        else:
21580 
          iprot.skip(ftype)
21581 
      elif fid == 3:
21582 
        if ftype == TType.I64:
21583 
          self.quantity = iprot.readI64();
21584 
        else:
21585 
          iprot.skip(ftype)
21586 
      elif fid == 4:
21587 
        if ftype == TType.I64:
21588 
          self.estimate = iprot.readI64();
21589 
        else:
21590 
          iprot.skip(ftype)
4369 rajveer 21591 
      elif fid == 5:
21592 
        if ftype == TType.BOOL:
21593 
          self.isReminder = iprot.readBool();
21594 
        else:
21595 
          iprot.skip(ftype)
4303 rajveer 21596 
      else:
21597 
        iprot.skip(ftype)
21598 
      iprot.readFieldEnd()
21599 
    iprot.readStructEnd()
21600 
 
21601 
  def write(self, oprot):
21602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21604 
      return
21605 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21606 
    if self.vendorId is not None:
21607 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21608 
      oprot.writeI64(self.vendorId)
21609 
      oprot.writeFieldEnd()
21610 
    if self.itemId is not None:
21611 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21612 
      oprot.writeI64(self.itemId)
21613 
      oprot.writeFieldEnd()
21614 
    if self.quantity is not None:
21615 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21616 
      oprot.writeI64(self.quantity)
21617 
      oprot.writeFieldEnd()
21618 
    if self.estimate is not None:
21619 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21620 
      oprot.writeI64(self.estimate)
21621 
      oprot.writeFieldEnd()
4369 rajveer 21622 
    if self.isReminder is not None:
21623 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21624 
      oprot.writeBool(self.isReminder)
21625 
      oprot.writeFieldEnd()
4303 rajveer 21626 
    oprot.writeFieldStop()
21627 
    oprot.writeStructEnd()
21628 
 
21629 
  def validate(self):
21630 
    return
21631 
 
21632 
 
21633 
  def __repr__(self):
21634 
    L = ['%s=%r' % (key, value)
21635 
      for key, value in self.__dict__.iteritems()]
21636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21637 
 
21638 
  def __eq__(self, other):
21639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21640 
 
21641 
  def __ne__(self, other):
21642 
    return not (self == other)
21643 
 
21644 
class markOrdersAsPORaised_result:
21645 
  """
21646 
  Attributes:
21647 
   - ex
21648 
  """
21649 
 
21650 
  thrift_spec = (
21651 
    None, # 0
21652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21653 
  )
21654 
 
21655 
  def __init__(self, ex=None,):
21656 
    self.ex = ex
21657 
 
21658 
  def read(self, iprot):
21659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21661 
      return
21662 
    iprot.readStructBegin()
21663 
    while True:
21664 
      (fname, ftype, fid) = iprot.readFieldBegin()
21665 
      if ftype == TType.STOP:
21666 
        break
21667 
      if fid == 1:
21668 
        if ftype == TType.STRUCT:
21669 
          self.ex = TransactionServiceException()
21670 
          self.ex.read(iprot)
21671 
        else:
21672 
          iprot.skip(ftype)
21673 
      else:
21674 
        iprot.skip(ftype)
21675 
      iprot.readFieldEnd()
21676 
    iprot.readStructEnd()
21677 
 
21678 
  def write(self, oprot):
21679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21681 
      return
21682 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21683 
    if self.ex is not None:
21684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21685 
      self.ex.write(oprot)
21686 
      oprot.writeFieldEnd()
21687 
    oprot.writeFieldStop()
21688 
    oprot.writeStructEnd()
21689 
 
21690 
  def validate(self):
21691 
    return
21692 
 
21693 
 
21694 
  def __repr__(self):
21695 
    L = ['%s=%r' % (key, value)
21696 
      for key, value in self.__dict__.iteritems()]
21697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21698 
 
21699 
  def __eq__(self, other):
21700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21701 
 
21702 
  def __ne__(self, other):
21703 
    return not (self == other)
21704 
 
21705 
class markOrdersAsReversalInitiated_args:
21706 
  """
21707 
  Attributes:
21708 
   - vendorId
21709 
   - itemId
21710 
   - quantity
21711 
   - estimate
4369 rajveer 21712 
   - isReminder
4303 rajveer 21713 
  """
21714 
 
21715 
  thrift_spec = (
21716 
    None, # 0
21717 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21718 
    (2, TType.I64, 'itemId', None, None, ), # 2
21719 
    (3, TType.I64, 'quantity', None, None, ), # 3
21720 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21721 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21722 
  )
21723 
 
4369 rajveer 21724 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21725 
    self.vendorId = vendorId
21726 
    self.itemId = itemId
21727 
    self.quantity = quantity
21728 
    self.estimate = estimate
4369 rajveer 21729 
    self.isReminder = isReminder
4303 rajveer 21730 
 
21731 
  def read(self, iprot):
21732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21734 
      return
21735 
    iprot.readStructBegin()
21736 
    while True:
21737 
      (fname, ftype, fid) = iprot.readFieldBegin()
21738 
      if ftype == TType.STOP:
21739 
        break
21740 
      if fid == 1:
21741 
        if ftype == TType.I64:
21742 
          self.vendorId = iprot.readI64();
21743 
        else:
21744 
          iprot.skip(ftype)
21745 
      elif fid == 2:
21746 
        if ftype == TType.I64:
21747 
          self.itemId = iprot.readI64();
21748 
        else:
21749 
          iprot.skip(ftype)
21750 
      elif fid == 3:
21751 
        if ftype == TType.I64:
21752 
          self.quantity = iprot.readI64();
21753 
        else:
21754 
          iprot.skip(ftype)
21755 
      elif fid == 4:
21756 
        if ftype == TType.I64:
21757 
          self.estimate = iprot.readI64();
21758 
        else:
21759 
          iprot.skip(ftype)
4369 rajveer 21760 
      elif fid == 5:
21761 
        if ftype == TType.BOOL:
21762 
          self.isReminder = iprot.readBool();
21763 
        else:
21764 
          iprot.skip(ftype)
4303 rajveer 21765 
      else:
21766 
        iprot.skip(ftype)
21767 
      iprot.readFieldEnd()
21768 
    iprot.readStructEnd()
21769 
 
21770 
  def write(self, oprot):
21771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21773 
      return
21774 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21775 
    if self.vendorId is not None:
21776 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21777 
      oprot.writeI64(self.vendorId)
21778 
      oprot.writeFieldEnd()
21779 
    if self.itemId is not None:
21780 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21781 
      oprot.writeI64(self.itemId)
21782 
      oprot.writeFieldEnd()
21783 
    if self.quantity is not None:
21784 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21785 
      oprot.writeI64(self.quantity)
21786 
      oprot.writeFieldEnd()
21787 
    if self.estimate is not None:
21788 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21789 
      oprot.writeI64(self.estimate)
21790 
      oprot.writeFieldEnd()
4369 rajveer 21791 
    if self.isReminder is not None:
21792 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21793 
      oprot.writeBool(self.isReminder)
21794 
      oprot.writeFieldEnd()
4303 rajveer 21795 
    oprot.writeFieldStop()
21796 
    oprot.writeStructEnd()
21797 
 
21798 
  def validate(self):
21799 
    return
21800 
 
21801 
 
21802 
  def __repr__(self):
21803 
    L = ['%s=%r' % (key, value)
21804 
      for key, value in self.__dict__.iteritems()]
21805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21806 
 
21807 
  def __eq__(self, other):
21808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21809 
 
21810 
  def __ne__(self, other):
21811 
    return not (self == other)
21812 
 
21813 
class markOrdersAsReversalInitiated_result:
21814 
  """
21815 
  Attributes:
21816 
   - ex
21817 
  """
21818 
 
21819 
  thrift_spec = (
21820 
    None, # 0
21821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21822 
  )
21823 
 
21824 
  def __init__(self, ex=None,):
21825 
    self.ex = ex
21826 
 
21827 
  def read(self, iprot):
21828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21830 
      return
21831 
    iprot.readStructBegin()
21832 
    while True:
21833 
      (fname, ftype, fid) = iprot.readFieldBegin()
21834 
      if ftype == TType.STOP:
21835 
        break
21836 
      if fid == 1:
21837 
        if ftype == TType.STRUCT:
21838 
          self.ex = TransactionServiceException()
21839 
          self.ex.read(iprot)
21840 
        else:
21841 
          iprot.skip(ftype)
21842 
      else:
21843 
        iprot.skip(ftype)
21844 
      iprot.readFieldEnd()
21845 
    iprot.readStructEnd()
21846 
 
21847 
  def write(self, oprot):
21848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21850 
      return
21851 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21852 
    if self.ex is not None:
21853 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21854 
      self.ex.write(oprot)
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 markOrdersAsNotAvailabke_args:
21875 
  """
21876 
  Attributes:
21877 
   - vendorId
21878 
   - itemId
21879 
   - quantity
21880 
   - estimate
4369 rajveer 21881 
   - isReminder
4303 rajveer 21882 
  """
21883 
 
21884 
  thrift_spec = (
21885 
    None, # 0
21886 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21887 
    (2, TType.I64, 'itemId', None, None, ), # 2
21888 
    (3, TType.I64, 'quantity', None, None, ), # 3
21889 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21890 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21891 
  )
21892 
 
4369 rajveer 21893 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21894 
    self.vendorId = vendorId
21895 
    self.itemId = itemId
21896 
    self.quantity = quantity
21897 
    self.estimate = estimate
4369 rajveer 21898 
    self.isReminder = isReminder
4303 rajveer 21899 
 
21900 
  def read(self, iprot):
21901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21903 
      return
21904 
    iprot.readStructBegin()
21905 
    while True:
21906 
      (fname, ftype, fid) = iprot.readFieldBegin()
21907 
      if ftype == TType.STOP:
21908 
        break
21909 
      if fid == 1:
21910 
        if ftype == TType.I64:
21911 
          self.vendorId = iprot.readI64();
21912 
        else:
21913 
          iprot.skip(ftype)
21914 
      elif fid == 2:
21915 
        if ftype == TType.I64:
21916 
          self.itemId = iprot.readI64();
21917 
        else:
21918 
          iprot.skip(ftype)
21919 
      elif fid == 3:
21920 
        if ftype == TType.I64:
21921 
          self.quantity = iprot.readI64();
21922 
        else:
21923 
          iprot.skip(ftype)
21924 
      elif fid == 4:
21925 
        if ftype == TType.I64:
21926 
          self.estimate = iprot.readI64();
21927 
        else:
21928 
          iprot.skip(ftype)
4369 rajveer 21929 
      elif fid == 5:
21930 
        if ftype == TType.BOOL:
21931 
          self.isReminder = iprot.readBool();
21932 
        else:
21933 
          iprot.skip(ftype)
4303 rajveer 21934 
      else:
21935 
        iprot.skip(ftype)
21936 
      iprot.readFieldEnd()
21937 
    iprot.readStructEnd()
21938 
 
21939 
  def write(self, oprot):
21940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21942 
      return
21943 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21944 
    if self.vendorId is not None:
21945 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21946 
      oprot.writeI64(self.vendorId)
21947 
      oprot.writeFieldEnd()
21948 
    if self.itemId is not None:
21949 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21950 
      oprot.writeI64(self.itemId)
21951 
      oprot.writeFieldEnd()
21952 
    if self.quantity is not None:
21953 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21954 
      oprot.writeI64(self.quantity)
21955 
      oprot.writeFieldEnd()
21956 
    if self.estimate is not None:
21957 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21958 
      oprot.writeI64(self.estimate)
21959 
      oprot.writeFieldEnd()
4369 rajveer 21960 
    if self.isReminder is not None:
21961 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21962 
      oprot.writeBool(self.isReminder)
21963 
      oprot.writeFieldEnd()
4303 rajveer 21964 
    oprot.writeFieldStop()
21965 
    oprot.writeStructEnd()
21966 
 
21967 
  def validate(self):
21968 
    return
21969 
 
21970 
 
21971 
  def __repr__(self):
21972 
    L = ['%s=%r' % (key, value)
21973 
      for key, value in self.__dict__.iteritems()]
21974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21975 
 
21976 
  def __eq__(self, other):
21977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21978 
 
21979 
  def __ne__(self, other):
21980 
    return not (self == other)
21981 
 
21982 
class markOrdersAsNotAvailabke_result:
21983 
  """
21984 
  Attributes:
21985 
   - ex
21986 
  """
21987 
 
21988 
  thrift_spec = (
21989 
    None, # 0
21990 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21991 
  )
21992 
 
21993 
  def __init__(self, ex=None,):
21994 
    self.ex = ex
21995 
 
21996 
  def read(self, iprot):
21997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21999 
      return
22000 
    iprot.readStructBegin()
22001 
    while True:
22002 
      (fname, ftype, fid) = iprot.readFieldBegin()
22003 
      if ftype == TType.STOP:
22004 
        break
22005 
      if fid == 1:
22006 
        if ftype == TType.STRUCT:
22007 
          self.ex = TransactionServiceException()
22008 
          self.ex.read(iprot)
22009 
        else:
22010 
          iprot.skip(ftype)
22011 
      else:
22012 
        iprot.skip(ftype)
22013 
      iprot.readFieldEnd()
22014 
    iprot.readStructEnd()
22015 
 
22016 
  def write(self, oprot):
22017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22019 
      return
22020 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22021 
    if self.ex is not None:
22022 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22023 
      self.ex.write(oprot)
22024 
      oprot.writeFieldEnd()
22025 
    oprot.writeFieldStop()
22026 
    oprot.writeStructEnd()
22027 
 
22028 
  def validate(self):
22029 
    return
22030 
 
22031 
 
22032 
  def __repr__(self):
22033 
    L = ['%s=%r' % (key, value)
22034 
      for key, value in self.__dict__.iteritems()]
22035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22036 
 
22037 
  def __eq__(self, other):
22038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22039 
 
22040 
  def __ne__(self, other):
22041 
    return not (self == other)
4369 rajveer 22042 
 
22043 
class markOrdersAsTimeout_args:
22044 
  """
22045 
  Attributes:
22046 
   - vendorId
22047 
  """
22048 
 
22049 
  thrift_spec = (
22050 
    None, # 0
22051 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22052 
  )
22053 
 
22054 
  def __init__(self, vendorId=None,):
22055 
    self.vendorId = vendorId
22056 
 
22057 
  def read(self, iprot):
22058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22060 
      return
22061 
    iprot.readStructBegin()
22062 
    while True:
22063 
      (fname, ftype, fid) = iprot.readFieldBegin()
22064 
      if ftype == TType.STOP:
22065 
        break
22066 
      if fid == 1:
22067 
        if ftype == TType.I64:
22068 
          self.vendorId = iprot.readI64();
22069 
        else:
22070 
          iprot.skip(ftype)
22071 
      else:
22072 
        iprot.skip(ftype)
22073 
      iprot.readFieldEnd()
22074 
    iprot.readStructEnd()
22075 
 
22076 
  def write(self, oprot):
22077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22079 
      return
22080 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22081 
    if self.vendorId is not None:
22082 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22083 
      oprot.writeI64(self.vendorId)
22084 
      oprot.writeFieldEnd()
22085 
    oprot.writeFieldStop()
22086 
    oprot.writeStructEnd()
22087 
 
22088 
  def validate(self):
22089 
    return
22090 
 
22091 
 
22092 
  def __repr__(self):
22093 
    L = ['%s=%r' % (key, value)
22094 
      for key, value in self.__dict__.iteritems()]
22095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22096 
 
22097 
  def __eq__(self, other):
22098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22099 
 
22100 
  def __ne__(self, other):
22101 
    return not (self == other)
22102 
 
22103 
class markOrdersAsTimeout_result:
22104 
  """
22105 
  Attributes:
22106 
   - success
22107 
   - ex
22108 
  """
22109 
 
22110 
  thrift_spec = (
22111 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22112 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22113 
  )
22114 
 
22115 
  def __init__(self, success=None, ex=None,):
22116 
    self.success = success
22117 
    self.ex = ex
22118 
 
22119 
  def read(self, iprot):
22120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22122 
      return
22123 
    iprot.readStructBegin()
22124 
    while True:
22125 
      (fname, ftype, fid) = iprot.readFieldBegin()
22126 
      if ftype == TType.STOP:
22127 
        break
22128 
      if fid == 0:
22129 
        if ftype == TType.MAP:
22130 
          self.success = {}
6188 rajveer 22131 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22132 
          for _i505 in xrange(_size501):
22133 
            _key506 = iprot.readI32();
22134 
            _val507 = TimeoutSummary()
22135 
            _val507.read(iprot)
22136 
            self.success[_key506] = _val507
4369 rajveer 22137 
          iprot.readMapEnd()
22138 
        else:
22139 
          iprot.skip(ftype)
22140 
      elif fid == 1:
22141 
        if ftype == TType.STRUCT:
22142 
          self.ex = TransactionServiceException()
22143 
          self.ex.read(iprot)
22144 
        else:
22145 
          iprot.skip(ftype)
22146 
      else:
22147 
        iprot.skip(ftype)
22148 
      iprot.readFieldEnd()
22149 
    iprot.readStructEnd()
22150 
 
22151 
  def write(self, oprot):
22152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22154 
      return
22155 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22156 
    if self.success is not None:
22157 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22158 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22159 
      for kiter508,viter509 in self.success.items():
22160 
        oprot.writeI32(kiter508)
22161 
        viter509.write(oprot)
4369 rajveer 22162 
      oprot.writeMapEnd()
22163 
      oprot.writeFieldEnd()
22164 
    if self.ex is not None:
22165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22166 
      self.ex.write(oprot)
22167 
      oprot.writeFieldEnd()
22168 
    oprot.writeFieldStop()
22169 
    oprot.writeStructEnd()
22170 
 
22171 
  def validate(self):
22172 
    return
22173 
 
22174 
 
22175 
  def __repr__(self):
22176 
    L = ['%s=%r' % (key, value)
22177 
      for key, value in self.__dict__.iteritems()]
22178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22179 
 
22180 
  def __eq__(self, other):
22181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22182 
 
22183 
  def __ne__(self, other):
22184 
    return not (self == other)
4386 anupam.sin 22185 
 
4662 rajveer 22186 
class markOrderAsLostInTransit_args:
22187 
  """
22188 
  Attributes:
22189 
   - orderId
22190 
  """
22191 
 
22192 
  thrift_spec = (
22193 
    None, # 0
22194 
    (1, TType.I64, 'orderId', None, None, ), # 1
22195 
  )
22196 
 
22197 
  def __init__(self, orderId=None,):
22198 
    self.orderId = orderId
22199 
 
22200 
  def read(self, iprot):
22201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22203 
      return
22204 
    iprot.readStructBegin()
22205 
    while True:
22206 
      (fname, ftype, fid) = iprot.readFieldBegin()
22207 
      if ftype == TType.STOP:
22208 
        break
22209 
      if fid == 1:
22210 
        if ftype == TType.I64:
22211 
          self.orderId = iprot.readI64();
22212 
        else:
22213 
          iprot.skip(ftype)
22214 
      else:
22215 
        iprot.skip(ftype)
22216 
      iprot.readFieldEnd()
22217 
    iprot.readStructEnd()
22218 
 
22219 
  def write(self, oprot):
22220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22222 
      return
22223 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22224 
    if self.orderId is not None:
22225 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22226 
      oprot.writeI64(self.orderId)
22227 
      oprot.writeFieldEnd()
22228 
    oprot.writeFieldStop()
22229 
    oprot.writeStructEnd()
22230 
 
22231 
  def validate(self):
22232 
    return
22233 
 
22234 
 
22235 
  def __repr__(self):
22236 
    L = ['%s=%r' % (key, value)
22237 
      for key, value in self.__dict__.iteritems()]
22238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22239 
 
22240 
  def __eq__(self, other):
22241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22242 
 
22243 
  def __ne__(self, other):
22244 
    return not (self == other)
22245 
 
22246 
class markOrderAsLostInTransit_result:
22247 
  """
22248 
  Attributes:
22249 
   - success
22250 
   - ex
22251 
  """
22252 
 
22253 
  thrift_spec = (
22254 
    (0, TType.BOOL, 'success', None, None, ), # 0
22255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22256 
  )
22257 
 
22258 
  def __init__(self, success=None, ex=None,):
22259 
    self.success = success
22260 
    self.ex = ex
22261 
 
22262 
  def read(self, iprot):
22263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22265 
      return
22266 
    iprot.readStructBegin()
22267 
    while True:
22268 
      (fname, ftype, fid) = iprot.readFieldBegin()
22269 
      if ftype == TType.STOP:
22270 
        break
22271 
      if fid == 0:
22272 
        if ftype == TType.BOOL:
22273 
          self.success = iprot.readBool();
22274 
        else:
22275 
          iprot.skip(ftype)
22276 
      elif fid == 1:
22277 
        if ftype == TType.STRUCT:
22278 
          self.ex = TransactionServiceException()
22279 
          self.ex.read(iprot)
22280 
        else:
22281 
          iprot.skip(ftype)
22282 
      else:
22283 
        iprot.skip(ftype)
22284 
      iprot.readFieldEnd()
22285 
    iprot.readStructEnd()
22286 
 
22287 
  def write(self, oprot):
22288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22290 
      return
22291 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22292 
    if self.success is not None:
22293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22294 
      oprot.writeBool(self.success)
22295 
      oprot.writeFieldEnd()
22296 
    if self.ex is not None:
22297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22298 
      self.ex.write(oprot)
22299 
      oprot.writeFieldEnd()
22300 
    oprot.writeFieldStop()
22301 
    oprot.writeStructEnd()
22302 
 
22303 
  def validate(self):
22304 
    return
22305 
 
22306 
 
22307 
  def __repr__(self):
22308 
    L = ['%s=%r' % (key, value)
22309 
      for key, value in self.__dict__.iteritems()]
22310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22311 
 
22312 
  def __eq__(self, other):
22313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22314 
 
22315 
  def __ne__(self, other):
22316 
    return not (self == other)
22317 
 
4386 anupam.sin 22318 
class getOrderForAwb_args:
22319 
  """
22320 
  Attributes:
22321 
   - awb
22322 
  """
22323 
 
22324 
  thrift_spec = (
22325 
    None, # 0
22326 
    (1, TType.STRING, 'awb', None, None, ), # 1
22327 
  )
22328 
 
22329 
  def __init__(self, awb=None,):
22330 
    self.awb = awb
22331 
 
22332 
  def read(self, iprot):
22333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22335 
      return
22336 
    iprot.readStructBegin()
22337 
    while True:
22338 
      (fname, ftype, fid) = iprot.readFieldBegin()
22339 
      if ftype == TType.STOP:
22340 
        break
22341 
      if fid == 1:
22342 
        if ftype == TType.STRING:
22343 
          self.awb = iprot.readString();
22344 
        else:
22345 
          iprot.skip(ftype)
22346 
      else:
22347 
        iprot.skip(ftype)
22348 
      iprot.readFieldEnd()
22349 
    iprot.readStructEnd()
22350 
 
22351 
  def write(self, oprot):
22352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22354 
      return
22355 
    oprot.writeStructBegin('getOrderForAwb_args')
22356 
    if self.awb is not None:
22357 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22358 
      oprot.writeString(self.awb)
22359 
      oprot.writeFieldEnd()
22360 
    oprot.writeFieldStop()
22361 
    oprot.writeStructEnd()
22362 
 
22363 
  def validate(self):
22364 
    return
22365 
 
22366 
 
22367 
  def __repr__(self):
22368 
    L = ['%s=%r' % (key, value)
22369 
      for key, value in self.__dict__.iteritems()]
22370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22371 
 
22372 
  def __eq__(self, other):
22373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22374 
 
22375 
  def __ne__(self, other):
22376 
    return not (self == other)
22377 
 
22378 
class getOrderForAwb_result:
22379 
  """
22380 
  Attributes:
22381 
   - success
22382 
   - ex
22383 
  """
22384 
 
22385 
  thrift_spec = (
22386 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22388 
  )
22389 
 
22390 
  def __init__(self, success=None, ex=None,):
22391 
    self.success = success
22392 
    self.ex = ex
22393 
 
22394 
  def read(self, iprot):
22395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22397 
      return
22398 
    iprot.readStructBegin()
22399 
    while True:
22400 
      (fname, ftype, fid) = iprot.readFieldBegin()
22401 
      if ftype == TType.STOP:
22402 
        break
22403 
      if fid == 0:
22404 
        if ftype == TType.STRUCT:
22405 
          self.success = Order()
22406 
          self.success.read(iprot)
22407 
        else:
22408 
          iprot.skip(ftype)
22409 
      elif fid == 1:
22410 
        if ftype == TType.STRUCT:
22411 
          self.ex = TransactionServiceException()
22412 
          self.ex.read(iprot)
22413 
        else:
22414 
          iprot.skip(ftype)
22415 
      else:
22416 
        iprot.skip(ftype)
22417 
      iprot.readFieldEnd()
22418 
    iprot.readStructEnd()
22419 
 
22420 
  def write(self, oprot):
22421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22423 
      return
22424 
    oprot.writeStructBegin('getOrderForAwb_result')
22425 
    if self.success is not None:
22426 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22427 
      self.success.write(oprot)
22428 
      oprot.writeFieldEnd()
22429 
    if self.ex is not None:
22430 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22431 
      self.ex.write(oprot)
22432 
      oprot.writeFieldEnd()
22433 
    oprot.writeFieldStop()
22434 
    oprot.writeStructEnd()
22435 
 
22436 
  def validate(self):
22437 
    return
22438 
 
22439 
 
22440 
  def __repr__(self):
22441 
    L = ['%s=%r' % (key, value)
22442 
      for key, value in self.__dict__.iteritems()]
22443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22444 
 
22445 
  def __eq__(self, other):
22446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22447 
 
22448 
  def __ne__(self, other):
22449 
    return not (self == other)
4506 phani.kuma 22450 
 
22451 
class getOrdersForProviderForStatus_args:
22452 
  """
22453 
  Attributes:
22454 
   - logistics_provider_id
4910 phani.kuma 22455 
   - order_status_list
4506 phani.kuma 22456 
  """
22457 
 
22458 
  thrift_spec = (
22459 
    None, # 0
22460 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22461 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22462 
  )
22463 
 
4910 phani.kuma 22464 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22465 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22466 
    self.order_status_list = order_status_list
4506 phani.kuma 22467 
 
22468 
  def read(self, iprot):
22469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22471 
      return
22472 
    iprot.readStructBegin()
22473 
    while True:
22474 
      (fname, ftype, fid) = iprot.readFieldBegin()
22475 
      if ftype == TType.STOP:
22476 
        break
22477 
      if fid == 1:
22478 
        if ftype == TType.I64:
22479 
          self.logistics_provider_id = iprot.readI64();
22480 
        else:
22481 
          iprot.skip(ftype)
22482 
      elif fid == 2:
4910 phani.kuma 22483 
        if ftype == TType.LIST:
22484 
          self.order_status_list = []
6188 rajveer 22485 
          (_etype513, _size510) = iprot.readListBegin()
22486 
          for _i514 in xrange(_size510):
22487 
            _elem515 = iprot.readI32();
22488 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22489 
          iprot.readListEnd()
4506 phani.kuma 22490 
        else:
22491 
          iprot.skip(ftype)
22492 
      else:
22493 
        iprot.skip(ftype)
22494 
      iprot.readFieldEnd()
22495 
    iprot.readStructEnd()
22496 
 
22497 
  def write(self, oprot):
22498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22500 
      return
22501 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22502 
    if self.logistics_provider_id is not None:
22503 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22504 
      oprot.writeI64(self.logistics_provider_id)
22505 
      oprot.writeFieldEnd()
4910 phani.kuma 22506 
    if self.order_status_list is not None:
22507 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22508 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22509 
      for iter516 in self.order_status_list:
22510 
        oprot.writeI32(iter516)
4910 phani.kuma 22511 
      oprot.writeListEnd()
4506 phani.kuma 22512 
      oprot.writeFieldEnd()
22513 
    oprot.writeFieldStop()
22514 
    oprot.writeStructEnd()
22515 
 
22516 
  def validate(self):
22517 
    return
22518 
 
22519 
 
22520 
  def __repr__(self):
22521 
    L = ['%s=%r' % (key, value)
22522 
      for key, value in self.__dict__.iteritems()]
22523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22524 
 
22525 
  def __eq__(self, other):
22526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22527 
 
22528 
  def __ne__(self, other):
22529 
    return not (self == other)
22530 
 
22531 
class getOrdersForProviderForStatus_result:
22532 
  """
22533 
  Attributes:
22534 
   - success
22535 
   - ex
22536 
  """
22537 
 
22538 
  thrift_spec = (
22539 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22540 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22541 
  )
22542 
 
22543 
  def __init__(self, success=None, ex=None,):
22544 
    self.success = success
22545 
    self.ex = ex
22546 
 
22547 
  def read(self, iprot):
22548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22550 
      return
22551 
    iprot.readStructBegin()
22552 
    while True:
22553 
      (fname, ftype, fid) = iprot.readFieldBegin()
22554 
      if ftype == TType.STOP:
22555 
        break
22556 
      if fid == 0:
22557 
        if ftype == TType.LIST:
22558 
          self.success = []
6188 rajveer 22559 
          (_etype520, _size517) = iprot.readListBegin()
22560 
          for _i521 in xrange(_size517):
22561 
            _elem522 = Order()
22562 
            _elem522.read(iprot)
22563 
            self.success.append(_elem522)
4506 phani.kuma 22564 
          iprot.readListEnd()
22565 
        else:
22566 
          iprot.skip(ftype)
22567 
      elif fid == 1:
22568 
        if ftype == TType.STRUCT:
22569 
          self.ex = TransactionServiceException()
22570 
          self.ex.read(iprot)
22571 
        else:
22572 
          iprot.skip(ftype)
22573 
      else:
22574 
        iprot.skip(ftype)
22575 
      iprot.readFieldEnd()
22576 
    iprot.readStructEnd()
22577 
 
22578 
  def write(self, oprot):
22579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22581 
      return
22582 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22583 
    if self.success is not None:
22584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22586 
      for iter523 in self.success:
22587 
        iter523.write(oprot)
4506 phani.kuma 22588 
      oprot.writeListEnd()
22589 
      oprot.writeFieldEnd()
22590 
    if self.ex is not None:
22591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22592 
      self.ex.write(oprot)
22593 
      oprot.writeFieldEnd()
22594 
    oprot.writeFieldStop()
22595 
    oprot.writeStructEnd()
22596 
 
22597 
  def validate(self):
22598 
    return
22599 
 
22600 
 
22601 
  def __repr__(self):
22602 
    L = ['%s=%r' % (key, value)
22603 
      for key, value in self.__dict__.iteritems()]
22604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22605 
 
22606 
  def __eq__(self, other):
22607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22608 
 
22609 
  def __ne__(self, other):
22610 
    return not (self == other)
4600 varun.gupt 22611 
 
22612 
class getBilledOrdersForVendor_args:
22613 
  """
22614 
  Attributes:
22615 
   - vendorId
22616 
   - billingDateFrom
22617 
   - billingDateTo
22618 
  """
22619 
 
22620 
  thrift_spec = (
22621 
    None, # 0
22622 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22623 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22624 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22625 
  )
22626 
 
22627 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22628 
    self.vendorId = vendorId
22629 
    self.billingDateFrom = billingDateFrom
22630 
    self.billingDateTo = billingDateTo
22631 
 
22632 
  def read(self, iprot):
22633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22635 
      return
22636 
    iprot.readStructBegin()
22637 
    while True:
22638 
      (fname, ftype, fid) = iprot.readFieldBegin()
22639 
      if ftype == TType.STOP:
22640 
        break
22641 
      if fid == 1:
22642 
        if ftype == TType.I64:
22643 
          self.vendorId = iprot.readI64();
22644 
        else:
22645 
          iprot.skip(ftype)
22646 
      elif fid == 2:
22647 
        if ftype == TType.I64:
22648 
          self.billingDateFrom = iprot.readI64();
22649 
        else:
22650 
          iprot.skip(ftype)
22651 
      elif fid == 3:
22652 
        if ftype == TType.I64:
22653 
          self.billingDateTo = iprot.readI64();
22654 
        else:
22655 
          iprot.skip(ftype)
22656 
      else:
22657 
        iprot.skip(ftype)
22658 
      iprot.readFieldEnd()
22659 
    iprot.readStructEnd()
22660 
 
22661 
  def write(self, oprot):
22662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22664 
      return
22665 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22666 
    if self.vendorId is not None:
22667 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22668 
      oprot.writeI64(self.vendorId)
22669 
      oprot.writeFieldEnd()
22670 
    if self.billingDateFrom is not None:
22671 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22672 
      oprot.writeI64(self.billingDateFrom)
22673 
      oprot.writeFieldEnd()
22674 
    if self.billingDateTo is not None:
22675 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22676 
      oprot.writeI64(self.billingDateTo)
22677 
      oprot.writeFieldEnd()
22678 
    oprot.writeFieldStop()
22679 
    oprot.writeStructEnd()
22680 
 
22681 
  def validate(self):
22682 
    return
22683 
 
22684 
 
22685 
  def __repr__(self):
22686 
    L = ['%s=%r' % (key, value)
22687 
      for key, value in self.__dict__.iteritems()]
22688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22689 
 
22690 
  def __eq__(self, other):
22691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22692 
 
22693 
  def __ne__(self, other):
22694 
    return not (self == other)
22695 
 
22696 
class getBilledOrdersForVendor_result:
22697 
  """
22698 
  Attributes:
22699 
   - success
22700 
   - ex
22701 
  """
22702 
 
22703 
  thrift_spec = (
22704 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22706 
  )
22707 
 
22708 
  def __init__(self, success=None, ex=None,):
22709 
    self.success = success
22710 
    self.ex = ex
22711 
 
22712 
  def read(self, iprot):
22713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22715 
      return
22716 
    iprot.readStructBegin()
22717 
    while True:
22718 
      (fname, ftype, fid) = iprot.readFieldBegin()
22719 
      if ftype == TType.STOP:
22720 
        break
22721 
      if fid == 0:
22722 
        if ftype == TType.LIST:
22723 
          self.success = []
6188 rajveer 22724 
          (_etype527, _size524) = iprot.readListBegin()
22725 
          for _i528 in xrange(_size524):
22726 
            _elem529 = Order()
22727 
            _elem529.read(iprot)
22728 
            self.success.append(_elem529)
4600 varun.gupt 22729 
          iprot.readListEnd()
22730 
        else:
22731 
          iprot.skip(ftype)
22732 
      elif fid == 1:
22733 
        if ftype == TType.STRUCT:
22734 
          self.ex = TransactionServiceException()
22735 
          self.ex.read(iprot)
22736 
        else:
22737 
          iprot.skip(ftype)
22738 
      else:
22739 
        iprot.skip(ftype)
22740 
      iprot.readFieldEnd()
22741 
    iprot.readStructEnd()
22742 
 
22743 
  def write(self, oprot):
22744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22746 
      return
22747 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22748 
    if self.success is not None:
22749 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22750 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22751 
      for iter530 in self.success:
22752 
        iter530.write(oprot)
4600 varun.gupt 22753 
      oprot.writeListEnd()
22754 
      oprot.writeFieldEnd()
22755 
    if self.ex is not None:
22756 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22757 
      self.ex.write(oprot)
22758 
      oprot.writeFieldEnd()
22759 
    oprot.writeFieldStop()
22760 
    oprot.writeStructEnd()
22761 
 
22762 
  def validate(self):
22763 
    return
22764 
 
22765 
 
22766 
  def __repr__(self):
22767 
    L = ['%s=%r' % (key, value)
22768 
      for key, value in self.__dict__.iteritems()]
22769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22770 
 
22771 
  def __eq__(self, other):
22772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22773 
 
22774 
  def __ne__(self, other):
22775 
    return not (self == other)
22776 
 
4607 rajveer 22777 
class getSlippedSippingDateOrders_args:
22778 
 
22779 
  thrift_spec = (
22780 
  )
22781 
 
22782 
  def read(self, iprot):
22783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22785 
      return
22786 
    iprot.readStructBegin()
22787 
    while True:
22788 
      (fname, ftype, fid) = iprot.readFieldBegin()
22789 
      if ftype == TType.STOP:
22790 
        break
22791 
      else:
22792 
        iprot.skip(ftype)
22793 
      iprot.readFieldEnd()
22794 
    iprot.readStructEnd()
22795 
 
22796 
  def write(self, oprot):
22797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22799 
      return
22800 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22801 
    oprot.writeFieldStop()
22802 
    oprot.writeStructEnd()
22803 
 
22804 
  def validate(self):
22805 
    return
22806 
 
22807 
 
22808 
  def __repr__(self):
22809 
    L = ['%s=%r' % (key, value)
22810 
      for key, value in self.__dict__.iteritems()]
22811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22812 
 
22813 
  def __eq__(self, other):
22814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22815 
 
22816 
  def __ne__(self, other):
22817 
    return not (self == other)
22818 
 
22819 
class getSlippedSippingDateOrders_result:
22820 
  """
22821 
  Attributes:
22822 
   - success
22823 
   - ex
22824 
  """
22825 
 
22826 
  thrift_spec = (
22827 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22829 
  )
22830 
 
22831 
  def __init__(self, success=None, ex=None,):
22832 
    self.success = success
22833 
    self.ex = ex
22834 
 
22835 
  def read(self, iprot):
22836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22838 
      return
22839 
    iprot.readStructBegin()
22840 
    while True:
22841 
      (fname, ftype, fid) = iprot.readFieldBegin()
22842 
      if ftype == TType.STOP:
22843 
        break
22844 
      if fid == 0:
22845 
        if ftype == TType.LIST:
22846 
          self.success = []
6188 rajveer 22847 
          (_etype534, _size531) = iprot.readListBegin()
22848 
          for _i535 in xrange(_size531):
22849 
            _elem536 = Order()
22850 
            _elem536.read(iprot)
22851 
            self.success.append(_elem536)
4607 rajveer 22852 
          iprot.readListEnd()
22853 
        else:
22854 
          iprot.skip(ftype)
22855 
      elif fid == 1:
22856 
        if ftype == TType.STRUCT:
22857 
          self.ex = TransactionServiceException()
22858 
          self.ex.read(iprot)
22859 
        else:
22860 
          iprot.skip(ftype)
22861 
      else:
22862 
        iprot.skip(ftype)
22863 
      iprot.readFieldEnd()
22864 
    iprot.readStructEnd()
22865 
 
22866 
  def write(self, oprot):
22867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22869 
      return
22870 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22871 
    if self.success is not None:
22872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22874 
      for iter537 in self.success:
22875 
        iter537.write(oprot)
4607 rajveer 22876 
      oprot.writeListEnd()
22877 
      oprot.writeFieldEnd()
22878 
    if self.ex is not None:
22879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22880 
      self.ex.write(oprot)
22881 
      oprot.writeFieldEnd()
22882 
    oprot.writeFieldStop()
22883 
    oprot.writeStructEnd()
22884 
 
22885 
  def validate(self):
22886 
    return
22887 
 
22888 
 
22889 
  def __repr__(self):
22890 
    L = ['%s=%r' % (key, value)
22891 
      for key, value in self.__dict__.iteritems()]
22892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22893 
 
22894 
  def __eq__(self, other):
22895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22896 
 
22897 
  def __ne__(self, other):
22898 
    return not (self == other)
22899 
 
4709 rajveer 22900 
class getCancelledOrders_args:
22901 
  """
22902 
  Attributes:
22903 
   - cancelDateFrom
22904 
   - cancelDateTo
22905 
  """
22906 
 
22907 
  thrift_spec = (
22908 
    None, # 0
22909 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22910 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22911 
  )
22912 
 
22913 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22914 
    self.cancelDateFrom = cancelDateFrom
22915 
    self.cancelDateTo = cancelDateTo
22916 
 
22917 
  def read(self, iprot):
22918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22920 
      return
22921 
    iprot.readStructBegin()
22922 
    while True:
22923 
      (fname, ftype, fid) = iprot.readFieldBegin()
22924 
      if ftype == TType.STOP:
22925 
        break
22926 
      if fid == 1:
22927 
        if ftype == TType.I64:
22928 
          self.cancelDateFrom = iprot.readI64();
22929 
        else:
22930 
          iprot.skip(ftype)
22931 
      elif fid == 2:
22932 
        if ftype == TType.I64:
22933 
          self.cancelDateTo = iprot.readI64();
22934 
        else:
22935 
          iprot.skip(ftype)
22936 
      else:
22937 
        iprot.skip(ftype)
22938 
      iprot.readFieldEnd()
22939 
    iprot.readStructEnd()
22940 
 
22941 
  def write(self, oprot):
22942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22944 
      return
22945 
    oprot.writeStructBegin('getCancelledOrders_args')
22946 
    if self.cancelDateFrom is not None:
22947 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22948 
      oprot.writeI64(self.cancelDateFrom)
22949 
      oprot.writeFieldEnd()
22950 
    if self.cancelDateTo is not None:
22951 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22952 
      oprot.writeI64(self.cancelDateTo)
22953 
      oprot.writeFieldEnd()
22954 
    oprot.writeFieldStop()
22955 
    oprot.writeStructEnd()
22956 
 
22957 
  def validate(self):
22958 
    return
22959 
 
22960 
 
22961 
  def __repr__(self):
22962 
    L = ['%s=%r' % (key, value)
22963 
      for key, value in self.__dict__.iteritems()]
22964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22965 
 
22966 
  def __eq__(self, other):
22967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22968 
 
22969 
  def __ne__(self, other):
22970 
    return not (self == other)
22971 
 
22972 
class getCancelledOrders_result:
22973 
  """
22974 
  Attributes:
22975 
   - success
22976 
   - ex
22977 
  """
22978 
 
22979 
  thrift_spec = (
22980 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22982 
  )
22983 
 
22984 
  def __init__(self, success=None, ex=None,):
22985 
    self.success = success
22986 
    self.ex = ex
22987 
 
22988 
  def read(self, iprot):
22989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22991 
      return
22992 
    iprot.readStructBegin()
22993 
    while True:
22994 
      (fname, ftype, fid) = iprot.readFieldBegin()
22995 
      if ftype == TType.STOP:
22996 
        break
22997 
      if fid == 0:
22998 
        if ftype == TType.LIST:
22999 
          self.success = []
6188 rajveer 23000 
          (_etype541, _size538) = iprot.readListBegin()
23001 
          for _i542 in xrange(_size538):
23002 
            _elem543 = Order()
23003 
            _elem543.read(iprot)
23004 
            self.success.append(_elem543)
4709 rajveer 23005 
          iprot.readListEnd()
23006 
        else:
23007 
          iprot.skip(ftype)
23008 
      elif fid == 1:
23009 
        if ftype == TType.STRUCT:
23010 
          self.ex = TransactionServiceException()
23011 
          self.ex.read(iprot)
23012 
        else:
23013 
          iprot.skip(ftype)
23014 
      else:
23015 
        iprot.skip(ftype)
23016 
      iprot.readFieldEnd()
23017 
    iprot.readStructEnd()
23018 
 
23019 
  def write(self, oprot):
23020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23022 
      return
23023 
    oprot.writeStructBegin('getCancelledOrders_result')
23024 
    if self.success is not None:
23025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23027 
      for iter544 in self.success:
23028 
        iter544.write(oprot)
4709 rajveer 23029 
      oprot.writeListEnd()
23030 
      oprot.writeFieldEnd()
23031 
    if self.ex is not None:
23032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23033 
      self.ex.write(oprot)
23034 
      oprot.writeFieldEnd()
23035 
    oprot.writeFieldStop()
23036 
    oprot.writeStructEnd()
23037 
 
23038 
  def validate(self):
23039 
    return
23040 
 
23041 
 
23042 
  def __repr__(self):
23043 
    L = ['%s=%r' % (key, value)
23044 
      for key, value in self.__dict__.iteritems()]
23045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23046 
 
23047 
  def __eq__(self, other):
23048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23049 
 
23050 
  def __ne__(self, other):
23051 
    return not (self == other)
23052 
 
4600 varun.gupt 23053 
class saveBluedartSettlements_args:
23054 
  """
23055 
  Attributes:
23056 
   - mapAWBAndAmount
23057 
  """
23058 
 
23059 
  thrift_spec = (
23060 
    None, # 0
23061 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23062 
  )
23063 
 
23064 
  def __init__(self, mapAWBAndAmount=None,):
23065 
    self.mapAWBAndAmount = mapAWBAndAmount
23066 
 
23067 
  def read(self, iprot):
23068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23070 
      return
23071 
    iprot.readStructBegin()
23072 
    while True:
23073 
      (fname, ftype, fid) = iprot.readFieldBegin()
23074 
      if ftype == TType.STOP:
23075 
        break
23076 
      if fid == 1:
23077 
        if ftype == TType.MAP:
23078 
          self.mapAWBAndAmount = {}
6188 rajveer 23079 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23080 
          for _i549 in xrange(_size545):
23081 
            _key550 = iprot.readI64();
23082 
            _val551 = iprot.readDouble();
23083 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23084 
          iprot.readMapEnd()
23085 
        else:
23086 
          iprot.skip(ftype)
23087 
      else:
23088 
        iprot.skip(ftype)
23089 
      iprot.readFieldEnd()
23090 
    iprot.readStructEnd()
23091 
 
23092 
  def write(self, oprot):
23093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23095 
      return
23096 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23097 
    if self.mapAWBAndAmount is not None:
23098 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23099 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23100 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23101 
        oprot.writeI64(kiter552)
23102 
        oprot.writeDouble(viter553)
4600 varun.gupt 23103 
      oprot.writeMapEnd()
23104 
      oprot.writeFieldEnd()
23105 
    oprot.writeFieldStop()
23106 
    oprot.writeStructEnd()
23107 
 
23108 
  def validate(self):
23109 
    return
23110 
 
23111 
 
23112 
  def __repr__(self):
23113 
    L = ['%s=%r' % (key, value)
23114 
      for key, value in self.__dict__.iteritems()]
23115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23116 
 
23117 
  def __eq__(self, other):
23118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23119 
 
23120 
  def __ne__(self, other):
23121 
    return not (self == other)
23122 
 
23123 
class saveBluedartSettlements_result:
23124 
  """
23125 
  Attributes:
23126 
   - ex
23127 
  """
23128 
 
23129 
  thrift_spec = (
23130 
    None, # 0
23131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23132 
  )
23133 
 
23134 
  def __init__(self, ex=None,):
23135 
    self.ex = ex
23136 
 
23137 
  def read(self, iprot):
23138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23140 
      return
23141 
    iprot.readStructBegin()
23142 
    while True:
23143 
      (fname, ftype, fid) = iprot.readFieldBegin()
23144 
      if ftype == TType.STOP:
23145 
        break
23146 
      if fid == 1:
23147 
        if ftype == TType.STRUCT:
23148 
          self.ex = TransactionServiceException()
23149 
          self.ex.read(iprot)
23150 
        else:
23151 
          iprot.skip(ftype)
23152 
      else:
23153 
        iprot.skip(ftype)
23154 
      iprot.readFieldEnd()
23155 
    iprot.readStructEnd()
23156 
 
23157 
  def write(self, oprot):
23158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23160 
      return
23161 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23162 
    if self.ex is not None:
23163 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23164 
      self.ex.write(oprot)
23165 
      oprot.writeFieldEnd()
23166 
    oprot.writeFieldStop()
23167 
    oprot.writeStructEnd()
23168 
 
23169 
  def validate(self):
23170 
    return
23171 
 
23172 
 
23173 
  def __repr__(self):
23174 
    L = ['%s=%r' % (key, value)
23175 
      for key, value in self.__dict__.iteritems()]
23176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23177 
 
23178 
  def __eq__(self, other):
23179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23180 
 
23181 
  def __ne__(self, other):
23182 
    return not (self == other)
23183 
 
23184 
class savePaymentSettlements_args:
23185 
  """
23186 
  Attributes:
23187 
   - settlementDate
23188 
   - paymentGatewayId
4905 varun.gupt 23189 
   - referenceId
4600 varun.gupt 23190 
   - serviceTax
23191 
   - otherCharges
23192 
   - netCollection
23193 
  """
23194 
 
23195 
  thrift_spec = (
23196 
    None, # 0
23197 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23198 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23199 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23200 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23201 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23202 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23203 
  )
23204 
 
4905 varun.gupt 23205 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23206 
    self.settlementDate = settlementDate
23207 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23208 
    self.referenceId = referenceId
4600 varun.gupt 23209 
    self.serviceTax = serviceTax
23210 
    self.otherCharges = otherCharges
23211 
    self.netCollection = netCollection
23212 
 
23213 
  def read(self, iprot):
23214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23216 
      return
23217 
    iprot.readStructBegin()
23218 
    while True:
23219 
      (fname, ftype, fid) = iprot.readFieldBegin()
23220 
      if ftype == TType.STOP:
23221 
        break
23222 
      if fid == 1:
23223 
        if ftype == TType.I64:
23224 
          self.settlementDate = iprot.readI64();
23225 
        else:
23226 
          iprot.skip(ftype)
23227 
      elif fid == 2:
23228 
        if ftype == TType.I64:
23229 
          self.paymentGatewayId = iprot.readI64();
23230 
        else:
23231 
          iprot.skip(ftype)
23232 
      elif fid == 3:
23233 
        if ftype == TType.I64:
4905 varun.gupt 23234 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23235 
        else:
23236 
          iprot.skip(ftype)
23237 
      elif fid == 4:
23238 
        if ftype == TType.DOUBLE:
23239 
          self.serviceTax = iprot.readDouble();
23240 
        else:
23241 
          iprot.skip(ftype)
23242 
      elif fid == 5:
23243 
        if ftype == TType.DOUBLE:
23244 
          self.otherCharges = iprot.readDouble();
23245 
        else:
23246 
          iprot.skip(ftype)
23247 
      elif fid == 6:
23248 
        if ftype == TType.DOUBLE:
23249 
          self.netCollection = iprot.readDouble();
23250 
        else:
23251 
          iprot.skip(ftype)
23252 
      else:
23253 
        iprot.skip(ftype)
23254 
      iprot.readFieldEnd()
23255 
    iprot.readStructEnd()
23256 
 
23257 
  def write(self, oprot):
23258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23260 
      return
23261 
    oprot.writeStructBegin('savePaymentSettlements_args')
23262 
    if self.settlementDate is not None:
23263 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23264 
      oprot.writeI64(self.settlementDate)
23265 
      oprot.writeFieldEnd()
23266 
    if self.paymentGatewayId is not None:
23267 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23268 
      oprot.writeI64(self.paymentGatewayId)
23269 
      oprot.writeFieldEnd()
4905 varun.gupt 23270 
    if self.referenceId is not None:
23271 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23272 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23273 
      oprot.writeFieldEnd()
23274 
    if self.serviceTax is not None:
23275 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23276 
      oprot.writeDouble(self.serviceTax)
23277 
      oprot.writeFieldEnd()
23278 
    if self.otherCharges is not None:
23279 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23280 
      oprot.writeDouble(self.otherCharges)
23281 
      oprot.writeFieldEnd()
23282 
    if self.netCollection is not None:
23283 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23284 
      oprot.writeDouble(self.netCollection)
23285 
      oprot.writeFieldEnd()
23286 
    oprot.writeFieldStop()
23287 
    oprot.writeStructEnd()
23288 
 
23289 
  def validate(self):
23290 
    return
23291 
 
23292 
 
23293 
  def __repr__(self):
23294 
    L = ['%s=%r' % (key, value)
23295 
      for key, value in self.__dict__.iteritems()]
23296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23297 
 
23298 
  def __eq__(self, other):
23299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23300 
 
23301 
  def __ne__(self, other):
23302 
    return not (self == other)
23303 
 
23304 
class savePaymentSettlements_result:
23305 
  """
23306 
  Attributes:
23307 
   - ex
23308 
  """
23309 
 
23310 
  thrift_spec = (
23311 
    None, # 0
23312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23313 
  )
23314 
 
23315 
  def __init__(self, ex=None,):
23316 
    self.ex = ex
23317 
 
23318 
  def read(self, iprot):
23319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23321 
      return
23322 
    iprot.readStructBegin()
23323 
    while True:
23324 
      (fname, ftype, fid) = iprot.readFieldBegin()
23325 
      if ftype == TType.STOP:
23326 
        break
23327 
      if fid == 1:
23328 
        if ftype == TType.STRUCT:
23329 
          self.ex = TransactionServiceException()
23330 
          self.ex.read(iprot)
23331 
        else:
23332 
          iprot.skip(ftype)
23333 
      else:
23334 
        iprot.skip(ftype)
23335 
      iprot.readFieldEnd()
23336 
    iprot.readStructEnd()
23337 
 
23338 
  def write(self, oprot):
23339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23341 
      return
23342 
    oprot.writeStructBegin('savePaymentSettlements_result')
23343 
    if self.ex is not None:
23344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23345 
      self.ex.write(oprot)
23346 
      oprot.writeFieldEnd()
23347 
    oprot.writeFieldStop()
23348 
    oprot.writeStructEnd()
23349 
 
23350 
  def validate(self):
23351 
    return
23352 
 
23353 
 
23354 
  def __repr__(self):
23355 
    L = ['%s=%r' % (key, value)
23356 
      for key, value in self.__dict__.iteritems()]
23357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23358 
 
23359 
  def __eq__(self, other):
23360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23361 
 
23362 
  def __ne__(self, other):
23363 
    return not (self == other)
23364 
 
23365 
class saveEBSSettlementSummary_args:
23366 
  """
23367 
  Attributes:
23368 
   - settlementId
23369 
   - settlementDate
23370 
   - transactionDateFrom
23371 
   - transactionDateTo
23372 
   - amount
23373 
  """
23374 
 
23375 
  thrift_spec = (
23376 
    None, # 0
23377 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23378 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23379 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23380 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23381 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23382 
  )
23383 
 
23384 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23385 
    self.settlementId = settlementId
23386 
    self.settlementDate = settlementDate
23387 
    self.transactionDateFrom = transactionDateFrom
23388 
    self.transactionDateTo = transactionDateTo
23389 
    self.amount = amount
23390 
 
23391 
  def read(self, iprot):
23392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23394 
      return
23395 
    iprot.readStructBegin()
23396 
    while True:
23397 
      (fname, ftype, fid) = iprot.readFieldBegin()
23398 
      if ftype == TType.STOP:
23399 
        break
23400 
      if fid == 1:
23401 
        if ftype == TType.I64:
23402 
          self.settlementId = iprot.readI64();
23403 
        else:
23404 
          iprot.skip(ftype)
23405 
      elif fid == 2:
23406 
        if ftype == TType.I64:
23407 
          self.settlementDate = iprot.readI64();
23408 
        else:
23409 
          iprot.skip(ftype)
23410 
      elif fid == 3:
23411 
        if ftype == TType.I64:
23412 
          self.transactionDateFrom = iprot.readI64();
23413 
        else:
23414 
          iprot.skip(ftype)
23415 
      elif fid == 4:
23416 
        if ftype == TType.I64:
23417 
          self.transactionDateTo = iprot.readI64();
23418 
        else:
23419 
          iprot.skip(ftype)
23420 
      elif fid == 5:
23421 
        if ftype == TType.DOUBLE:
23422 
          self.amount = iprot.readDouble();
23423 
        else:
23424 
          iprot.skip(ftype)
23425 
      else:
23426 
        iprot.skip(ftype)
23427 
      iprot.readFieldEnd()
23428 
    iprot.readStructEnd()
23429 
 
23430 
  def write(self, oprot):
23431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23433 
      return
23434 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23435 
    if self.settlementId is not None:
23436 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23437 
      oprot.writeI64(self.settlementId)
23438 
      oprot.writeFieldEnd()
23439 
    if self.settlementDate is not None:
23440 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23441 
      oprot.writeI64(self.settlementDate)
23442 
      oprot.writeFieldEnd()
23443 
    if self.transactionDateFrom is not None:
23444 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23445 
      oprot.writeI64(self.transactionDateFrom)
23446 
      oprot.writeFieldEnd()
23447 
    if self.transactionDateTo is not None:
23448 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23449 
      oprot.writeI64(self.transactionDateTo)
23450 
      oprot.writeFieldEnd()
23451 
    if self.amount is not None:
23452 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23453 
      oprot.writeDouble(self.amount)
23454 
      oprot.writeFieldEnd()
23455 
    oprot.writeFieldStop()
23456 
    oprot.writeStructEnd()
23457 
 
23458 
  def validate(self):
23459 
    return
23460 
 
23461 
 
23462 
  def __repr__(self):
23463 
    L = ['%s=%r' % (key, value)
23464 
      for key, value in self.__dict__.iteritems()]
23465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23466 
 
23467 
  def __eq__(self, other):
23468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23469 
 
23470 
  def __ne__(self, other):
23471 
    return not (self == other)
23472 
 
23473 
class saveEBSSettlementSummary_result:
23474 
  """
23475 
  Attributes:
23476 
   - ex
23477 
  """
23478 
 
23479 
  thrift_spec = (
23480 
    None, # 0
23481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23482 
  )
23483 
 
23484 
  def __init__(self, ex=None,):
23485 
    self.ex = ex
23486 
 
23487 
  def read(self, iprot):
23488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23490 
      return
23491 
    iprot.readStructBegin()
23492 
    while True:
23493 
      (fname, ftype, fid) = iprot.readFieldBegin()
23494 
      if ftype == TType.STOP:
23495 
        break
23496 
      if fid == 1:
23497 
        if ftype == TType.STRUCT:
23498 
          self.ex = TransactionServiceException()
23499 
          self.ex.read(iprot)
23500 
        else:
23501 
          iprot.skip(ftype)
23502 
      else:
23503 
        iprot.skip(ftype)
23504 
      iprot.readFieldEnd()
23505 
    iprot.readStructEnd()
23506 
 
23507 
  def write(self, oprot):
23508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23510 
      return
23511 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23512 
    if self.ex is not None:
23513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23514 
      self.ex.write(oprot)
23515 
      oprot.writeFieldEnd()
23516 
    oprot.writeFieldStop()
23517 
    oprot.writeStructEnd()
23518 
 
23519 
  def validate(self):
23520 
    return
23521 
 
23522 
 
23523 
  def __repr__(self):
23524 
    L = ['%s=%r' % (key, value)
23525 
      for key, value in self.__dict__.iteritems()]
23526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23527 
 
23528 
  def __eq__(self, other):
23529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23530 
 
23531 
  def __ne__(self, other):
23532 
    return not (self == other)
23533 
 
5386 phani.kuma 23534 
class getSettlementForPrepaid_args:
4600 varun.gupt 23535 
  """
23536 
  Attributes:
5189 varun.gupt 23537 
   - referenceId
23538 
   - isRefund
4600 varun.gupt 23539 
  """
23540 
 
23541 
  thrift_spec = (
23542 
    None, # 0
5189 varun.gupt 23543 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23544 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23545 
  )
23546 
 
5386 phani.kuma 23547 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23548 
    self.referenceId = referenceId
23549 
    self.isRefund = isRefund
4600 varun.gupt 23550 
 
23551 
  def read(self, iprot):
23552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23554 
      return
23555 
    iprot.readStructBegin()
23556 
    while True:
23557 
      (fname, ftype, fid) = iprot.readFieldBegin()
23558 
      if ftype == TType.STOP:
23559 
        break
23560 
      if fid == 1:
23561 
        if ftype == TType.I64:
5189 varun.gupt 23562 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23563 
        else:
23564 
          iprot.skip(ftype)
5189 varun.gupt 23565 
      elif fid == 2:
23566 
        if ftype == TType.BOOL:
23567 
          self.isRefund = iprot.readBool();
23568 
        else:
23569 
          iprot.skip(ftype)
4600 varun.gupt 23570 
      else:
23571 
        iprot.skip(ftype)
23572 
      iprot.readFieldEnd()
23573 
    iprot.readStructEnd()
23574 
 
23575 
  def write(self, oprot):
23576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23578 
      return
5386 phani.kuma 23579 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23580 
    if self.referenceId is not None:
23581 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23582 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23583 
      oprot.writeFieldEnd()
5386 phani.kuma 23584 
    if self.isRefund is not None:
23585 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23586 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23587 
      oprot.writeFieldEnd()
5386 phani.kuma 23588 
    oprot.writeFieldStop()
23589 
    oprot.writeStructEnd()
23590 
 
23591 
  def validate(self):
23592 
    return
23593 
 
23594 
 
23595 
  def __repr__(self):
23596 
    L = ['%s=%r' % (key, value)
23597 
      for key, value in self.__dict__.iteritems()]
23598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23599 
 
23600 
  def __eq__(self, other):
23601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23602 
 
23603 
  def __ne__(self, other):
23604 
    return not (self == other)
23605 
 
23606 
class getSettlementForPrepaid_result:
23607 
  """
23608 
  Attributes:
23609 
   - success
23610 
   - ex
23611 
  """
23612 
 
23613 
  thrift_spec = (
23614 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23616 
  )
23617 
 
23618 
  def __init__(self, success=None, ex=None,):
23619 
    self.success = success
23620 
    self.ex = ex
23621 
 
23622 
  def read(self, iprot):
23623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23625 
      return
23626 
    iprot.readStructBegin()
23627 
    while True:
23628 
      (fname, ftype, fid) = iprot.readFieldBegin()
23629 
      if ftype == TType.STOP:
23630 
        break
23631 
      if fid == 0:
23632 
        if ftype == TType.STRUCT:
23633 
          self.success = PaymentSettlement()
23634 
          self.success.read(iprot)
23635 
        else:
23636 
          iprot.skip(ftype)
23637 
      elif fid == 1:
23638 
        if ftype == TType.STRUCT:
23639 
          self.ex = TransactionServiceException()
23640 
          self.ex.read(iprot)
23641 
        else:
23642 
          iprot.skip(ftype)
23643 
      else:
23644 
        iprot.skip(ftype)
23645 
      iprot.readFieldEnd()
23646 
    iprot.readStructEnd()
23647 
 
23648 
  def write(self, oprot):
23649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23651 
      return
23652 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23653 
    if self.success is not None:
23654 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23655 
      self.success.write(oprot)
23656 
      oprot.writeFieldEnd()
23657 
    if self.ex is not None:
23658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23659 
      self.ex.write(oprot)
23660 
      oprot.writeFieldEnd()
23661 
    oprot.writeFieldStop()
23662 
    oprot.writeStructEnd()
23663 
 
23664 
  def validate(self):
23665 
    return
23666 
 
23667 
 
23668 
  def __repr__(self):
23669 
    L = ['%s=%r' % (key, value)
23670 
      for key, value in self.__dict__.iteritems()]
23671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23672 
 
23673 
  def __eq__(self, other):
23674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23675 
 
23676 
  def __ne__(self, other):
23677 
    return not (self == other)
23678 
 
23679 
class getSettlementForCod_args:
23680 
  """
23681 
  Attributes:
23682 
   - orderId
23683 
   - isRefund
23684 
  """
23685 
 
23686 
  thrift_spec = (
23687 
    None, # 0
23688 
    (1, TType.I64, 'orderId', None, None, ), # 1
23689 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23690 
  )
23691 
 
23692 
  def __init__(self, orderId=None, isRefund=None,):
23693 
    self.orderId = orderId
23694 
    self.isRefund = isRefund
23695 
 
23696 
  def read(self, iprot):
23697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23699 
      return
23700 
    iprot.readStructBegin()
23701 
    while True:
23702 
      (fname, ftype, fid) = iprot.readFieldBegin()
23703 
      if ftype == TType.STOP:
23704 
        break
23705 
      if fid == 1:
23706 
        if ftype == TType.I64:
23707 
          self.orderId = iprot.readI64();
23708 
        else:
23709 
          iprot.skip(ftype)
23710 
      elif fid == 2:
23711 
        if ftype == TType.BOOL:
23712 
          self.isRefund = iprot.readBool();
23713 
        else:
23714 
          iprot.skip(ftype)
23715 
      else:
23716 
        iprot.skip(ftype)
23717 
      iprot.readFieldEnd()
23718 
    iprot.readStructEnd()
23719 
 
23720 
  def write(self, oprot):
23721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23723 
      return
23724 
    oprot.writeStructBegin('getSettlementForCod_args')
23725 
    if self.orderId is not None:
23726 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23727 
      oprot.writeI64(self.orderId)
23728 
      oprot.writeFieldEnd()
5189 varun.gupt 23729 
    if self.isRefund is not None:
5386 phani.kuma 23730 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23731 
      oprot.writeBool(self.isRefund)
23732 
      oprot.writeFieldEnd()
4600 varun.gupt 23733 
    oprot.writeFieldStop()
23734 
    oprot.writeStructEnd()
23735 
 
23736 
  def validate(self):
23737 
    return
23738 
 
23739 
 
23740 
  def __repr__(self):
23741 
    L = ['%s=%r' % (key, value)
23742 
      for key, value in self.__dict__.iteritems()]
23743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23744 
 
23745 
  def __eq__(self, other):
23746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23747 
 
23748 
  def __ne__(self, other):
23749 
    return not (self == other)
23750 
 
5386 phani.kuma 23751 
class getSettlementForCod_result:
4600 varun.gupt 23752 
  """
23753 
  Attributes:
23754 
   - success
23755 
   - ex
23756 
  """
23757 
 
23758 
  thrift_spec = (
23759 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23761 
  )
23762 
 
23763 
  def __init__(self, success=None, ex=None,):
23764 
    self.success = success
23765 
    self.ex = ex
23766 
 
23767 
  def read(self, iprot):
23768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23770 
      return
23771 
    iprot.readStructBegin()
23772 
    while True:
23773 
      (fname, ftype, fid) = iprot.readFieldBegin()
23774 
      if ftype == TType.STOP:
23775 
        break
23776 
      if fid == 0:
23777 
        if ftype == TType.STRUCT:
23778 
          self.success = PaymentSettlement()
23779 
          self.success.read(iprot)
23780 
        else:
23781 
          iprot.skip(ftype)
23782 
      elif fid == 1:
23783 
        if ftype == TType.STRUCT:
23784 
          self.ex = TransactionServiceException()
23785 
          self.ex.read(iprot)
23786 
        else:
23787 
          iprot.skip(ftype)
23788 
      else:
23789 
        iprot.skip(ftype)
23790 
      iprot.readFieldEnd()
23791 
    iprot.readStructEnd()
23792 
 
23793 
  def write(self, oprot):
23794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23796 
      return
5386 phani.kuma 23797 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23798 
    if self.success is not None:
23799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23800 
      self.success.write(oprot)
23801 
      oprot.writeFieldEnd()
23802 
    if self.ex is not None:
23803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23804 
      self.ex.write(oprot)
23805 
      oprot.writeFieldEnd()
23806 
    oprot.writeFieldStop()
23807 
    oprot.writeStructEnd()
23808 
 
23809 
  def validate(self):
23810 
    return
23811 
 
23812 
 
23813 
  def __repr__(self):
23814 
    L = ['%s=%r' % (key, value)
23815 
      for key, value in self.__dict__.iteritems()]
23816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23817 
 
23818 
  def __eq__(self, other):
23819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23820 
 
23821 
  def __ne__(self, other):
23822 
    return not (self == other)
23823 
 
23824 
class getEBSSettlementSummaries_args:
23825 
 
23826 
  thrift_spec = (
23827 
  )
23828 
 
23829 
  def read(self, iprot):
23830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23832 
      return
23833 
    iprot.readStructBegin()
23834 
    while True:
23835 
      (fname, ftype, fid) = iprot.readFieldBegin()
23836 
      if ftype == TType.STOP:
23837 
        break
23838 
      else:
23839 
        iprot.skip(ftype)
23840 
      iprot.readFieldEnd()
23841 
    iprot.readStructEnd()
23842 
 
23843 
  def write(self, oprot):
23844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23846 
      return
23847 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23848 
    oprot.writeFieldStop()
23849 
    oprot.writeStructEnd()
23850 
 
23851 
  def validate(self):
23852 
    return
23853 
 
23854 
 
23855 
  def __repr__(self):
23856 
    L = ['%s=%r' % (key, value)
23857 
      for key, value in self.__dict__.iteritems()]
23858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23859 
 
23860 
  def __eq__(self, other):
23861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23862 
 
23863 
  def __ne__(self, other):
23864 
    return not (self == other)
23865 
 
23866 
class getEBSSettlementSummaries_result:
23867 
  """
23868 
  Attributes:
23869 
   - success
23870 
   - ex
23871 
  """
23872 
 
23873 
  thrift_spec = (
23874 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23875 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23876 
  )
23877 
 
23878 
  def __init__(self, success=None, ex=None,):
23879 
    self.success = success
23880 
    self.ex = ex
23881 
 
23882 
  def read(self, iprot):
23883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23885 
      return
23886 
    iprot.readStructBegin()
23887 
    while True:
23888 
      (fname, ftype, fid) = iprot.readFieldBegin()
23889 
      if ftype == TType.STOP:
23890 
        break
23891 
      if fid == 0:
23892 
        if ftype == TType.MAP:
23893 
          self.success = {}
6188 rajveer 23894 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23895 
          for _i558 in xrange(_size554):
23896 
            _key559 = iprot.readI64();
23897 
            _val560 = iprot.readString();
23898 
            self.success[_key559] = _val560
4600 varun.gupt 23899 
          iprot.readMapEnd()
23900 
        else:
23901 
          iprot.skip(ftype)
23902 
      elif fid == 1:
23903 
        if ftype == TType.STRUCT:
23904 
          self.ex = TransactionServiceException()
23905 
          self.ex.read(iprot)
23906 
        else:
23907 
          iprot.skip(ftype)
23908 
      else:
23909 
        iprot.skip(ftype)
23910 
      iprot.readFieldEnd()
23911 
    iprot.readStructEnd()
23912 
 
23913 
  def write(self, oprot):
23914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23916 
      return
23917 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23918 
    if self.success is not None:
23919 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23920 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23921 
      for kiter561,viter562 in self.success.items():
23922 
        oprot.writeI64(kiter561)
23923 
        oprot.writeString(viter562)
4600 varun.gupt 23924 
      oprot.writeMapEnd()
23925 
      oprot.writeFieldEnd()
23926 
    if self.ex is not None:
23927 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23928 
      self.ex.write(oprot)
23929 
      oprot.writeFieldEnd()
23930 
    oprot.writeFieldStop()
23931 
    oprot.writeStructEnd()
23932 
 
23933 
  def validate(self):
23934 
    return
23935 
 
23936 
 
23937 
  def __repr__(self):
23938 
    L = ['%s=%r' % (key, value)
23939 
      for key, value in self.__dict__.iteritems()]
23940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23941 
 
23942 
  def __eq__(self, other):
23943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23944 
 
23945 
  def __ne__(self, other):
23946 
    return not (self == other)
23947 
 
23948 
class markEBSSettlementUploaded_args:
23949 
  """
23950 
  Attributes:
23951 
   - settlementId
23952 
  """
23953 
 
23954 
  thrift_spec = (
23955 
    None, # 0
23956 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23957 
  )
23958 
 
23959 
  def __init__(self, settlementId=None,):
23960 
    self.settlementId = settlementId
23961 
 
23962 
  def read(self, iprot):
23963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23965 
      return
23966 
    iprot.readStructBegin()
23967 
    while True:
23968 
      (fname, ftype, fid) = iprot.readFieldBegin()
23969 
      if ftype == TType.STOP:
23970 
        break
23971 
      if fid == 1:
23972 
        if ftype == TType.I64:
23973 
          self.settlementId = iprot.readI64();
23974 
        else:
23975 
          iprot.skip(ftype)
23976 
      else:
23977 
        iprot.skip(ftype)
23978 
      iprot.readFieldEnd()
23979 
    iprot.readStructEnd()
23980 
 
23981 
  def write(self, oprot):
23982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23984 
      return
23985 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23986 
    if self.settlementId is not None:
23987 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23988 
      oprot.writeI64(self.settlementId)
23989 
      oprot.writeFieldEnd()
23990 
    oprot.writeFieldStop()
23991 
    oprot.writeStructEnd()
23992 
 
23993 
  def validate(self):
23994 
    return
23995 
 
23996 
 
23997 
  def __repr__(self):
23998 
    L = ['%s=%r' % (key, value)
23999 
      for key, value in self.__dict__.iteritems()]
24000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24001 
 
24002 
  def __eq__(self, other):
24003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24004 
 
24005 
  def __ne__(self, other):
24006 
    return not (self == other)
24007 
 
24008 
class markEBSSettlementUploaded_result:
24009 
  """
24010 
  Attributes:
24011 
   - ex
24012 
  """
24013 
 
24014 
  thrift_spec = (
24015 
    None, # 0
24016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24017 
  )
24018 
 
24019 
  def __init__(self, ex=None,):
24020 
    self.ex = ex
24021 
 
24022 
  def read(self, iprot):
24023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24025 
      return
24026 
    iprot.readStructBegin()
24027 
    while True:
24028 
      (fname, ftype, fid) = iprot.readFieldBegin()
24029 
      if ftype == TType.STOP:
24030 
        break
24031 
      if fid == 1:
24032 
        if ftype == TType.STRUCT:
24033 
          self.ex = TransactionServiceException()
24034 
          self.ex.read(iprot)
24035 
        else:
24036 
          iprot.skip(ftype)
24037 
      else:
24038 
        iprot.skip(ftype)
24039 
      iprot.readFieldEnd()
24040 
    iprot.readStructEnd()
24041 
 
24042 
  def write(self, oprot):
24043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24045 
      return
24046 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24047 
    if self.ex is not None:
24048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24049 
      self.ex.write(oprot)
24050 
      oprot.writeFieldEnd()
24051 
    oprot.writeFieldStop()
24052 
    oprot.writeStructEnd()
24053 
 
24054 
  def validate(self):
24055 
    return
24056 
 
24057 
 
24058 
  def __repr__(self):
24059 
    L = ['%s=%r' % (key, value)
24060 
      for key, value in self.__dict__.iteritems()]
24061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24062 
 
24063 
  def __eq__(self, other):
24064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24065 
 
24066 
  def __ne__(self, other):
24067 
    return not (self == other)
24068 
 
24069 
class getEBSSettlementDate_args:
24070 
  """
24071 
  Attributes:
24072 
   - settlementId
24073 
  """
24074 
 
24075 
  thrift_spec = (
24076 
    None, # 0
24077 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24078 
  )
24079 
 
24080 
  def __init__(self, settlementId=None,):
24081 
    self.settlementId = settlementId
24082 
 
24083 
  def read(self, iprot):
24084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24086 
      return
24087 
    iprot.readStructBegin()
24088 
    while True:
24089 
      (fname, ftype, fid) = iprot.readFieldBegin()
24090 
      if ftype == TType.STOP:
24091 
        break
24092 
      if fid == 1:
24093 
        if ftype == TType.I64:
24094 
          self.settlementId = iprot.readI64();
24095 
        else:
24096 
          iprot.skip(ftype)
24097 
      else:
24098 
        iprot.skip(ftype)
24099 
      iprot.readFieldEnd()
24100 
    iprot.readStructEnd()
24101 
 
24102 
  def write(self, oprot):
24103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24105 
      return
24106 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24107 
    if self.settlementId is not None:
24108 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24109 
      oprot.writeI64(self.settlementId)
24110 
      oprot.writeFieldEnd()
24111 
    oprot.writeFieldStop()
24112 
    oprot.writeStructEnd()
24113 
 
24114 
  def validate(self):
24115 
    return
24116 
 
24117 
 
24118 
  def __repr__(self):
24119 
    L = ['%s=%r' % (key, value)
24120 
      for key, value in self.__dict__.iteritems()]
24121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24122 
 
24123 
  def __eq__(self, other):
24124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24125 
 
24126 
  def __ne__(self, other):
24127 
    return not (self == other)
24128 
 
24129 
class getEBSSettlementDate_result:
24130 
  """
24131 
  Attributes:
24132 
   - success
24133 
   - ex
24134 
  """
24135 
 
24136 
  thrift_spec = (
24137 
    (0, TType.I64, 'success', None, None, ), # 0
24138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24139 
  )
24140 
 
24141 
  def __init__(self, success=None, ex=None,):
24142 
    self.success = success
24143 
    self.ex = ex
24144 
 
24145 
  def read(self, iprot):
24146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24148 
      return
24149 
    iprot.readStructBegin()
24150 
    while True:
24151 
      (fname, ftype, fid) = iprot.readFieldBegin()
24152 
      if ftype == TType.STOP:
24153 
        break
24154 
      if fid == 0:
24155 
        if ftype == TType.I64:
24156 
          self.success = iprot.readI64();
24157 
        else:
24158 
          iprot.skip(ftype)
24159 
      elif fid == 1:
24160 
        if ftype == TType.STRUCT:
24161 
          self.ex = TransactionServiceException()
24162 
          self.ex.read(iprot)
24163 
        else:
24164 
          iprot.skip(ftype)
24165 
      else:
24166 
        iprot.skip(ftype)
24167 
      iprot.readFieldEnd()
24168 
    iprot.readStructEnd()
24169 
 
24170 
  def write(self, oprot):
24171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24173 
      return
24174 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24175 
    if self.success is not None:
24176 
      oprot.writeFieldBegin('success', TType.I64, 0)
24177 
      oprot.writeI64(self.success)
24178 
      oprot.writeFieldEnd()
24179 
    if self.ex is not None:
24180 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24181 
      self.ex.write(oprot)
24182 
      oprot.writeFieldEnd()
24183 
    oprot.writeFieldStop()
24184 
    oprot.writeStructEnd()
24185 
 
24186 
  def validate(self):
24187 
    return
24188 
 
24189 
 
24190 
  def __repr__(self):
24191 
    L = ['%s=%r' % (key, value)
24192 
      for key, value in self.__dict__.iteritems()]
24193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24194 
 
24195 
  def __eq__(self, other):
24196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24197 
 
24198 
  def __ne__(self, other):
24199 
    return not (self == other)
4715 varun.gupt 24200 
 
24201 
class getSettlementsByDate_args:
24202 
  """
24203 
  Attributes:
24204 
   - settlementDateFrom
24205 
   - settlementDateTo
24206 
   - isRefund
24207 
  """
24208 
 
24209 
  thrift_spec = (
24210 
    None, # 0
24211 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24212 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24213 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24214 
  )
24215 
 
24216 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24217 
    self.settlementDateFrom = settlementDateFrom
24218 
    self.settlementDateTo = settlementDateTo
24219 
    self.isRefund = isRefund
24220 
 
24221 
  def read(self, iprot):
24222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24224 
      return
24225 
    iprot.readStructBegin()
24226 
    while True:
24227 
      (fname, ftype, fid) = iprot.readFieldBegin()
24228 
      if ftype == TType.STOP:
24229 
        break
24230 
      if fid == 1:
24231 
        if ftype == TType.I64:
24232 
          self.settlementDateFrom = iprot.readI64();
24233 
        else:
24234 
          iprot.skip(ftype)
24235 
      elif fid == 2:
24236 
        if ftype == TType.I64:
24237 
          self.settlementDateTo = iprot.readI64();
24238 
        else:
24239 
          iprot.skip(ftype)
24240 
      elif fid == 3:
24241 
        if ftype == TType.BOOL:
24242 
          self.isRefund = iprot.readBool();
24243 
        else:
24244 
          iprot.skip(ftype)
24245 
      else:
24246 
        iprot.skip(ftype)
24247 
      iprot.readFieldEnd()
24248 
    iprot.readStructEnd()
24249 
 
24250 
  def write(self, oprot):
24251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24253 
      return
24254 
    oprot.writeStructBegin('getSettlementsByDate_args')
24255 
    if self.settlementDateFrom is not None:
24256 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24257 
      oprot.writeI64(self.settlementDateFrom)
24258 
      oprot.writeFieldEnd()
24259 
    if self.settlementDateTo is not None:
24260 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24261 
      oprot.writeI64(self.settlementDateTo)
24262 
      oprot.writeFieldEnd()
24263 
    if self.isRefund is not None:
24264 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24265 
      oprot.writeBool(self.isRefund)
24266 
      oprot.writeFieldEnd()
24267 
    oprot.writeFieldStop()
24268 
    oprot.writeStructEnd()
24269 
 
24270 
  def validate(self):
24271 
    return
24272 
 
24273 
 
24274 
  def __repr__(self):
24275 
    L = ['%s=%r' % (key, value)
24276 
      for key, value in self.__dict__.iteritems()]
24277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24278 
 
24279 
  def __eq__(self, other):
24280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24281 
 
24282 
  def __ne__(self, other):
24283 
    return not (self == other)
24284 
 
24285 
class getSettlementsByDate_result:
24286 
  """
24287 
  Attributes:
24288 
   - success
24289 
   - ex
24290 
  """
24291 
 
24292 
  thrift_spec = (
24293 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24294 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24295 
  )
24296 
 
24297 
  def __init__(self, success=None, ex=None,):
24298 
    self.success = success
24299 
    self.ex = ex
24300 
 
24301 
  def read(self, iprot):
24302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24304 
      return
24305 
    iprot.readStructBegin()
24306 
    while True:
24307 
      (fname, ftype, fid) = iprot.readFieldBegin()
24308 
      if ftype == TType.STOP:
24309 
        break
24310 
      if fid == 0:
24311 
        if ftype == TType.LIST:
24312 
          self.success = []
6188 rajveer 24313 
          (_etype566, _size563) = iprot.readListBegin()
24314 
          for _i567 in xrange(_size563):
24315 
            _elem568 = PaymentSettlement()
24316 
            _elem568.read(iprot)
24317 
            self.success.append(_elem568)
4715 varun.gupt 24318 
          iprot.readListEnd()
24319 
        else:
24320 
          iprot.skip(ftype)
24321 
      elif fid == 1:
24322 
        if ftype == TType.STRUCT:
24323 
          self.ex = TransactionServiceException()
24324 
          self.ex.read(iprot)
24325 
        else:
24326 
          iprot.skip(ftype)
24327 
      else:
24328 
        iprot.skip(ftype)
24329 
      iprot.readFieldEnd()
24330 
    iprot.readStructEnd()
24331 
 
24332 
  def write(self, oprot):
24333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24335 
      return
24336 
    oprot.writeStructBegin('getSettlementsByDate_result')
24337 
    if self.success is not None:
24338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24340 
      for iter569 in self.success:
24341 
        iter569.write(oprot)
4715 varun.gupt 24342 
      oprot.writeListEnd()
24343 
      oprot.writeFieldEnd()
24344 
    if self.ex is not None:
24345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24346 
      self.ex.write(oprot)
24347 
      oprot.writeFieldEnd()
24348 
    oprot.writeFieldStop()
24349 
    oprot.writeStructEnd()
24350 
 
24351 
  def validate(self):
24352 
    return
24353 
 
24354 
 
24355 
  def __repr__(self):
24356 
    L = ['%s=%r' % (key, value)
24357 
      for key, value in self.__dict__.iteritems()]
24358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24359 
 
24360 
  def __eq__(self, other):
24361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24362 
 
24363 
  def __ne__(self, other):
24364 
    return not (self == other)
24365 
 
24366 
class getReshippedOrderIds_args:
24367 
  """
24368 
  Attributes:
24369 
   - orderIds
24370 
  """
24371 
 
24372 
  thrift_spec = (
24373 
    None, # 0
24374 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24375 
  )
24376 
 
24377 
  def __init__(self, orderIds=None,):
24378 
    self.orderIds = orderIds
24379 
 
24380 
  def read(self, iprot):
24381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24383 
      return
24384 
    iprot.readStructBegin()
24385 
    while True:
24386 
      (fname, ftype, fid) = iprot.readFieldBegin()
24387 
      if ftype == TType.STOP:
24388 
        break
24389 
      if fid == 1:
24390 
        if ftype == TType.LIST:
24391 
          self.orderIds = []
6188 rajveer 24392 
          (_etype573, _size570) = iprot.readListBegin()
24393 
          for _i574 in xrange(_size570):
24394 
            _elem575 = iprot.readI64();
24395 
            self.orderIds.append(_elem575)
4715 varun.gupt 24396 
          iprot.readListEnd()
24397 
        else:
24398 
          iprot.skip(ftype)
24399 
      else:
24400 
        iprot.skip(ftype)
24401 
      iprot.readFieldEnd()
24402 
    iprot.readStructEnd()
24403 
 
24404 
  def write(self, oprot):
24405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24407 
      return
24408 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24409 
    if self.orderIds is not None:
24410 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24411 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24412 
      for iter576 in self.orderIds:
24413 
        oprot.writeI64(iter576)
4715 varun.gupt 24414 
      oprot.writeListEnd()
24415 
      oprot.writeFieldEnd()
24416 
    oprot.writeFieldStop()
24417 
    oprot.writeStructEnd()
24418 
 
24419 
  def validate(self):
24420 
    return
24421 
 
24422 
 
24423 
  def __repr__(self):
24424 
    L = ['%s=%r' % (key, value)
24425 
      for key, value in self.__dict__.iteritems()]
24426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24427 
 
24428 
  def __eq__(self, other):
24429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24430 
 
24431 
  def __ne__(self, other):
24432 
    return not (self == other)
24433 
 
24434 
class getReshippedOrderIds_result:
24435 
  """
24436 
  Attributes:
24437 
   - success
24438 
   - ex
24439 
  """
24440 
 
24441 
  thrift_spec = (
24442 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24444 
  )
24445 
 
24446 
  def __init__(self, success=None, ex=None,):
24447 
    self.success = success
24448 
    self.ex = ex
24449 
 
24450 
  def read(self, iprot):
24451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24453 
      return
24454 
    iprot.readStructBegin()
24455 
    while True:
24456 
      (fname, ftype, fid) = iprot.readFieldBegin()
24457 
      if ftype == TType.STOP:
24458 
        break
24459 
      if fid == 0:
24460 
        if ftype == TType.LIST:
24461 
          self.success = []
6188 rajveer 24462 
          (_etype580, _size577) = iprot.readListBegin()
24463 
          for _i581 in xrange(_size577):
24464 
            _elem582 = iprot.readI64();
24465 
            self.success.append(_elem582)
4715 varun.gupt 24466 
          iprot.readListEnd()
24467 
        else:
24468 
          iprot.skip(ftype)
24469 
      elif fid == 1:
24470 
        if ftype == TType.STRUCT:
24471 
          self.ex = TransactionServiceException()
24472 
          self.ex.read(iprot)
24473 
        else:
24474 
          iprot.skip(ftype)
24475 
      else:
24476 
        iprot.skip(ftype)
24477 
      iprot.readFieldEnd()
24478 
    iprot.readStructEnd()
24479 
 
24480 
  def write(self, oprot):
24481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24483 
      return
24484 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24485 
    if self.success is not None:
24486 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24487 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24488 
      for iter583 in self.success:
24489 
        oprot.writeI64(iter583)
4715 varun.gupt 24490 
      oprot.writeListEnd()
24491 
      oprot.writeFieldEnd()
24492 
    if self.ex is not None:
24493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24494 
      self.ex.write(oprot)
24495 
      oprot.writeFieldEnd()
24496 
    oprot.writeFieldStop()
24497 
    oprot.writeStructEnd()
24498 
 
24499 
  def validate(self):
24500 
    return
24501 
 
24502 
 
24503 
  def __repr__(self):
24504 
    L = ['%s=%r' % (key, value)
24505 
      for key, value in self.__dict__.iteritems()]
24506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24507 
 
24508 
  def __eq__(self, other):
24509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24510 
 
24511 
  def __ne__(self, other):
24512 
    return not (self == other)
4757 mandeep.dh 24513 
 
5481 phani.kuma 24514 
class getBilledOrders_args:
4875 varun.gupt 24515 
  """
24516 
  Attributes:
24517 
   - vendorId
5481 phani.kuma 24518 
   - onlyVendorNotPaid
24519 
   - billingDateFrom
24520 
   - billingDateTo
4875 varun.gupt 24521 
  """
24522 
 
24523 
  thrift_spec = (
24524 
    None, # 0
24525 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24526 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24527 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24528 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24529 
  )
24530 
 
5481 phani.kuma 24531 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24532 
    self.vendorId = vendorId
5481 phani.kuma 24533 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24534 
    self.billingDateFrom = billingDateFrom
24535 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24536 
 
24537 
  def read(self, iprot):
24538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24540 
      return
24541 
    iprot.readStructBegin()
24542 
    while True:
24543 
      (fname, ftype, fid) = iprot.readFieldBegin()
24544 
      if ftype == TType.STOP:
24545 
        break
24546 
      if fid == 1:
24547 
        if ftype == TType.I64:
24548 
          self.vendorId = iprot.readI64();
24549 
        else:
24550 
          iprot.skip(ftype)
5481 phani.kuma 24551 
      elif fid == 2:
24552 
        if ftype == TType.BOOL:
24553 
          self.onlyVendorNotPaid = iprot.readBool();
24554 
        else:
24555 
          iprot.skip(ftype)
24556 
      elif fid == 3:
24557 
        if ftype == TType.I64:
24558 
          self.billingDateFrom = iprot.readI64();
24559 
        else:
24560 
          iprot.skip(ftype)
24561 
      elif fid == 4:
24562 
        if ftype == TType.I64:
24563 
          self.billingDateTo = iprot.readI64();
24564 
        else:
24565 
          iprot.skip(ftype)
4875 varun.gupt 24566 
      else:
24567 
        iprot.skip(ftype)
24568 
      iprot.readFieldEnd()
24569 
    iprot.readStructEnd()
24570 
 
24571 
  def write(self, oprot):
24572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24574 
      return
5481 phani.kuma 24575 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24576 
    if self.vendorId is not None:
24577 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24578 
      oprot.writeI64(self.vendorId)
24579 
      oprot.writeFieldEnd()
5481 phani.kuma 24580 
    if self.onlyVendorNotPaid is not None:
24581 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24582 
      oprot.writeBool(self.onlyVendorNotPaid)
24583 
      oprot.writeFieldEnd()
24584 
    if self.billingDateFrom is not None:
24585 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24586 
      oprot.writeI64(self.billingDateFrom)
24587 
      oprot.writeFieldEnd()
24588 
    if self.billingDateTo is not None:
24589 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24590 
      oprot.writeI64(self.billingDateTo)
24591 
      oprot.writeFieldEnd()
4875 varun.gupt 24592 
    oprot.writeFieldStop()
24593 
    oprot.writeStructEnd()
24594 
 
24595 
  def validate(self):
24596 
    return
24597 
 
24598 
 
24599 
  def __repr__(self):
24600 
    L = ['%s=%r' % (key, value)
24601 
      for key, value in self.__dict__.iteritems()]
24602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24603 
 
24604 
  def __eq__(self, other):
24605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24606 
 
24607 
  def __ne__(self, other):
24608 
    return not (self == other)
24609 
 
5481 phani.kuma 24610 
class getBilledOrders_result:
4875 varun.gupt 24611 
  """
24612 
  Attributes:
24613 
   - success
24614 
   - ex
24615 
  """
24616 
 
24617 
  thrift_spec = (
24618 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24620 
  )
24621 
 
24622 
  def __init__(self, success=None, ex=None,):
24623 
    self.success = success
24624 
    self.ex = ex
24625 
 
24626 
  def read(self, iprot):
24627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24629 
      return
24630 
    iprot.readStructBegin()
24631 
    while True:
24632 
      (fname, ftype, fid) = iprot.readFieldBegin()
24633 
      if ftype == TType.STOP:
24634 
        break
24635 
      if fid == 0:
24636 
        if ftype == TType.LIST:
24637 
          self.success = []
6188 rajveer 24638 
          (_etype587, _size584) = iprot.readListBegin()
24639 
          for _i588 in xrange(_size584):
24640 
            _elem589 = Order()
24641 
            _elem589.read(iprot)
24642 
            self.success.append(_elem589)
4875 varun.gupt 24643 
          iprot.readListEnd()
24644 
        else:
24645 
          iprot.skip(ftype)
24646 
      elif fid == 1:
24647 
        if ftype == TType.STRUCT:
24648 
          self.ex = TransactionServiceException()
24649 
          self.ex.read(iprot)
24650 
        else:
24651 
          iprot.skip(ftype)
24652 
      else:
24653 
        iprot.skip(ftype)
24654 
      iprot.readFieldEnd()
24655 
    iprot.readStructEnd()
24656 
 
24657 
  def write(self, oprot):
24658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24660 
      return
5481 phani.kuma 24661 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24662 
    if self.success is not None:
24663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24664 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24665 
      for iter590 in self.success:
24666 
        iter590.write(oprot)
4875 varun.gupt 24667 
      oprot.writeListEnd()
24668 
      oprot.writeFieldEnd()
24669 
    if self.ex is not None:
24670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24671 
      self.ex.write(oprot)
24672 
      oprot.writeFieldEnd()
24673 
    oprot.writeFieldStop()
24674 
    oprot.writeStructEnd()
24675 
 
24676 
  def validate(self):
24677 
    return
24678 
 
24679 
 
24680 
  def __repr__(self):
24681 
    L = ['%s=%r' % (key, value)
24682 
      for key, value in self.__dict__.iteritems()]
24683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24684 
 
24685 
  def __eq__(self, other):
24686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24687 
 
24688 
  def __ne__(self, other):
24689 
    return not (self == other)
5031 varun.gupt 24690 
 
24691 
class getStatusDistributionOfOrders_args:
24692 
  """
24693 
  Attributes:
24694 
   - startDate
24695 
   - endDate
24696 
  """
24697 
 
24698 
  thrift_spec = (
24699 
    None, # 0
24700 
    (1, TType.I64, 'startDate', None, None, ), # 1
24701 
    (2, TType.I64, 'endDate', None, None, ), # 2
24702 
  )
24703 
 
24704 
  def __init__(self, startDate=None, endDate=None,):
24705 
    self.startDate = startDate
24706 
    self.endDate = endDate
24707 
 
24708 
  def read(self, iprot):
24709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24711 
      return
24712 
    iprot.readStructBegin()
24713 
    while True:
24714 
      (fname, ftype, fid) = iprot.readFieldBegin()
24715 
      if ftype == TType.STOP:
24716 
        break
24717 
      if fid == 1:
24718 
        if ftype == TType.I64:
24719 
          self.startDate = iprot.readI64();
24720 
        else:
24721 
          iprot.skip(ftype)
24722 
      elif fid == 2:
24723 
        if ftype == TType.I64:
24724 
          self.endDate = iprot.readI64();
24725 
        else:
24726 
          iprot.skip(ftype)
24727 
      else:
24728 
        iprot.skip(ftype)
24729 
      iprot.readFieldEnd()
24730 
    iprot.readStructEnd()
24731 
 
24732 
  def write(self, oprot):
24733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24735 
      return
24736 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24737 
    if self.startDate is not None:
24738 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24739 
      oprot.writeI64(self.startDate)
24740 
      oprot.writeFieldEnd()
24741 
    if self.endDate is not None:
24742 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24743 
      oprot.writeI64(self.endDate)
24744 
      oprot.writeFieldEnd()
24745 
    oprot.writeFieldStop()
24746 
    oprot.writeStructEnd()
24747 
 
24748 
  def validate(self):
24749 
    return
24750 
 
24751 
 
24752 
  def __repr__(self):
24753 
    L = ['%s=%r' % (key, value)
24754 
      for key, value in self.__dict__.iteritems()]
24755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24756 
 
24757 
  def __eq__(self, other):
24758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24759 
 
24760 
  def __ne__(self, other):
24761 
    return not (self == other)
24762 
 
24763 
class getStatusDistributionOfOrders_result:
24764 
  """
24765 
  Attributes:
24766 
   - success
24767 
   - ex
24768 
  """
24769 
 
24770 
  thrift_spec = (
24771 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24773 
  )
24774 
 
24775 
  def __init__(self, success=None, ex=None,):
24776 
    self.success = success
24777 
    self.ex = ex
24778 
 
24779 
  def read(self, iprot):
24780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24782 
      return
24783 
    iprot.readStructBegin()
24784 
    while True:
24785 
      (fname, ftype, fid) = iprot.readFieldBegin()
24786 
      if ftype == TType.STOP:
24787 
        break
24788 
      if fid == 0:
24789 
        if ftype == TType.MAP:
24790 
          self.success = {}
6188 rajveer 24791 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24792 
          for _i595 in xrange(_size591):
24793 
            _key596 = iprot.readI64();
24794 
            _val597 = iprot.readI64();
24795 
            self.success[_key596] = _val597
5031 varun.gupt 24796 
          iprot.readMapEnd()
24797 
        else:
24798 
          iprot.skip(ftype)
24799 
      elif fid == 1:
24800 
        if ftype == TType.STRUCT:
24801 
          self.ex = TransactionServiceException()
24802 
          self.ex.read(iprot)
24803 
        else:
24804 
          iprot.skip(ftype)
24805 
      else:
24806 
        iprot.skip(ftype)
24807 
      iprot.readFieldEnd()
24808 
    iprot.readStructEnd()
24809 
 
24810 
  def write(self, oprot):
24811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24813 
      return
24814 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24815 
    if self.success is not None:
24816 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24817 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24818 
      for kiter598,viter599 in self.success.items():
24819 
        oprot.writeI64(kiter598)
24820 
        oprot.writeI64(viter599)
5031 varun.gupt 24821 
      oprot.writeMapEnd()
24822 
      oprot.writeFieldEnd()
24823 
    if self.ex is not None:
24824 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24825 
      self.ex.write(oprot)
24826 
      oprot.writeFieldEnd()
24827 
    oprot.writeFieldStop()
24828 
    oprot.writeStructEnd()
24829 
 
24830 
  def validate(self):
24831 
    return
24832 
 
24833 
 
24834 
  def __repr__(self):
24835 
    L = ['%s=%r' % (key, value)
24836 
      for key, value in self.__dict__.iteritems()]
24837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24838 
 
24839 
  def __eq__(self, other):
24840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24841 
 
24842 
  def __ne__(self, other):
24843 
    return not (self == other)
5067 varun.gupt 24844 
 
24845 
class getOrderIdsForStatus_args:
24846 
  """
24847 
  Attributes:
24848 
   - status
24849 
   - startDatetime
24850 
   - endDatetime
24851 
  """
24852 
 
24853 
  thrift_spec = (
24854 
    None, # 0
24855 
    (1, TType.I64, 'status', None, None, ), # 1
24856 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24857 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24858 
  )
24859 
 
24860 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24861 
    self.status = status
24862 
    self.startDatetime = startDatetime
24863 
    self.endDatetime = endDatetime
24864 
 
24865 
  def read(self, iprot):
24866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24868 
      return
24869 
    iprot.readStructBegin()
24870 
    while True:
24871 
      (fname, ftype, fid) = iprot.readFieldBegin()
24872 
      if ftype == TType.STOP:
24873 
        break
24874 
      if fid == 1:
24875 
        if ftype == TType.I64:
24876 
          self.status = iprot.readI64();
24877 
        else:
24878 
          iprot.skip(ftype)
24879 
      elif fid == 2:
24880 
        if ftype == TType.I64:
24881 
          self.startDatetime = iprot.readI64();
24882 
        else:
24883 
          iprot.skip(ftype)
24884 
      elif fid == 3:
24885 
        if ftype == TType.I64:
24886 
          self.endDatetime = iprot.readI64();
24887 
        else:
24888 
          iprot.skip(ftype)
24889 
      else:
24890 
        iprot.skip(ftype)
24891 
      iprot.readFieldEnd()
24892 
    iprot.readStructEnd()
24893 
 
24894 
  def write(self, oprot):
24895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24897 
      return
24898 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24899 
    if self.status is not None:
24900 
      oprot.writeFieldBegin('status', TType.I64, 1)
24901 
      oprot.writeI64(self.status)
24902 
      oprot.writeFieldEnd()
24903 
    if self.startDatetime is not None:
24904 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24905 
      oprot.writeI64(self.startDatetime)
24906 
      oprot.writeFieldEnd()
24907 
    if self.endDatetime is not None:
24908 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24909 
      oprot.writeI64(self.endDatetime)
24910 
      oprot.writeFieldEnd()
24911 
    oprot.writeFieldStop()
24912 
    oprot.writeStructEnd()
24913 
 
24914 
  def validate(self):
24915 
    return
24916 
 
24917 
 
24918 
  def __repr__(self):
24919 
    L = ['%s=%r' % (key, value)
24920 
      for key, value in self.__dict__.iteritems()]
24921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24922 
 
24923 
  def __eq__(self, other):
24924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24925 
 
24926 
  def __ne__(self, other):
24927 
    return not (self == other)
24928 
 
24929 
class getOrderIdsForStatus_result:
24930 
  """
24931 
  Attributes:
24932 
   - success
24933 
   - ex
24934 
  """
24935 
 
24936 
  thrift_spec = (
24937 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24939 
  )
24940 
 
24941 
  def __init__(self, success=None, ex=None,):
24942 
    self.success = success
24943 
    self.ex = ex
24944 
 
24945 
  def read(self, iprot):
24946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24948 
      return
24949 
    iprot.readStructBegin()
24950 
    while True:
24951 
      (fname, ftype, fid) = iprot.readFieldBegin()
24952 
      if ftype == TType.STOP:
24953 
        break
24954 
      if fid == 0:
24955 
        if ftype == TType.LIST:
24956 
          self.success = []
6188 rajveer 24957 
          (_etype603, _size600) = iprot.readListBegin()
24958 
          for _i604 in xrange(_size600):
24959 
            _elem605 = iprot.readI64();
24960 
            self.success.append(_elem605)
5067 varun.gupt 24961 
          iprot.readListEnd()
24962 
        else:
24963 
          iprot.skip(ftype)
24964 
      elif fid == 1:
24965 
        if ftype == TType.STRUCT:
24966 
          self.ex = TransactionServiceException()
24967 
          self.ex.read(iprot)
24968 
        else:
24969 
          iprot.skip(ftype)
24970 
      else:
24971 
        iprot.skip(ftype)
24972 
      iprot.readFieldEnd()
24973 
    iprot.readStructEnd()
24974 
 
24975 
  def write(self, oprot):
24976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24978 
      return
24979 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24980 
    if self.success is not None:
24981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24982 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24983 
      for iter606 in self.success:
24984 
        oprot.writeI64(iter606)
5067 varun.gupt 24985 
      oprot.writeListEnd()
24986 
      oprot.writeFieldEnd()
24987 
    if self.ex is not None:
24988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24989 
      self.ex.write(oprot)
24990 
      oprot.writeFieldEnd()
24991 
    oprot.writeFieldStop()
24992 
    oprot.writeStructEnd()
24993 
 
24994 
  def validate(self):
24995 
    return
24996 
 
24997 
 
24998 
  def __repr__(self):
24999 
    L = ['%s=%r' % (key, value)
25000 
      for key, value in self.__dict__.iteritems()]
25001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25002 
 
25003 
  def __eq__(self, other):
25004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25005 
 
25006 
  def __ne__(self, other):
25007 
    return not (self == other)
5099 varun.gupt 25008 
 
5348 anupam.sin 25009 
class updateCODAgent_args:
25010 
  """
25011 
  Attributes:
25012 
   - agent
25013 
   - orderId
25014 
  """
25015 
 
25016 
  thrift_spec = (
25017 
    None, # 0
25018 
    (1, TType.STRING, 'agent', None, None, ), # 1
25019 
    (2, TType.I64, 'orderId', None, None, ), # 2
25020 
  )
25021 
 
25022 
  def __init__(self, agent=None, orderId=None,):
25023 
    self.agent = agent
25024 
    self.orderId = orderId
25025 
 
25026 
  def read(self, iprot):
25027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25029 
      return
25030 
    iprot.readStructBegin()
25031 
    while True:
25032 
      (fname, ftype, fid) = iprot.readFieldBegin()
25033 
      if ftype == TType.STOP:
25034 
        break
25035 
      if fid == 1:
25036 
        if ftype == TType.STRING:
25037 
          self.agent = iprot.readString();
25038 
        else:
25039 
          iprot.skip(ftype)
25040 
      elif fid == 2:
25041 
        if ftype == TType.I64:
25042 
          self.orderId = iprot.readI64();
25043 
        else:
25044 
          iprot.skip(ftype)
25045 
      else:
25046 
        iprot.skip(ftype)
25047 
      iprot.readFieldEnd()
25048 
    iprot.readStructEnd()
25049 
 
25050 
  def write(self, oprot):
25051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25053 
      return
25054 
    oprot.writeStructBegin('updateCODAgent_args')
25055 
    if self.agent is not None:
25056 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25057 
      oprot.writeString(self.agent)
25058 
      oprot.writeFieldEnd()
25059 
    if self.orderId is not None:
25060 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25061 
      oprot.writeI64(self.orderId)
25062 
      oprot.writeFieldEnd()
25063 
    oprot.writeFieldStop()
25064 
    oprot.writeStructEnd()
25065 
 
25066 
  def validate(self):
25067 
    return
25068 
 
25069 
 
25070 
  def __repr__(self):
25071 
    L = ['%s=%r' % (key, value)
25072 
      for key, value in self.__dict__.iteritems()]
25073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25074 
 
25075 
  def __eq__(self, other):
25076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25077 
 
25078 
  def __ne__(self, other):
25079 
    return not (self == other)
25080 
 
25081 
class updateCODAgent_result:
25082 
  """
25083 
  Attributes:
25084 
   - ex
25085 
  """
25086 
 
25087 
  thrift_spec = (
25088 
    None, # 0
25089 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25090 
  )
25091 
 
25092 
  def __init__(self, ex=None,):
25093 
    self.ex = ex
25094 
 
25095 
  def read(self, iprot):
25096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25098 
      return
25099 
    iprot.readStructBegin()
25100 
    while True:
25101 
      (fname, ftype, fid) = iprot.readFieldBegin()
25102 
      if ftype == TType.STOP:
25103 
        break
25104 
      if fid == 1:
25105 
        if ftype == TType.STRUCT:
25106 
          self.ex = TransactionServiceException()
25107 
          self.ex.read(iprot)
25108 
        else:
25109 
          iprot.skip(ftype)
25110 
      else:
25111 
        iprot.skip(ftype)
25112 
      iprot.readFieldEnd()
25113 
    iprot.readStructEnd()
25114 
 
25115 
  def write(self, oprot):
25116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25118 
      return
25119 
    oprot.writeStructBegin('updateCODAgent_result')
25120 
    if self.ex is not None:
25121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25122 
      self.ex.write(oprot)
25123 
      oprot.writeFieldEnd()
25124 
    oprot.writeFieldStop()
25125 
    oprot.writeStructEnd()
25126 
 
25127 
  def validate(self):
25128 
    return
25129 
 
25130 
 
25131 
  def __repr__(self):
25132 
    L = ['%s=%r' % (key, value)
25133 
      for key, value in self.__dict__.iteritems()]
25134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25135 
 
25136 
  def __eq__(self, other):
25137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25138 
 
25139 
  def __ne__(self, other):
25140 
    return not (self == other)
25141 
 
5099 varun.gupt 25142 
class updateOrderAsPaidToVendor_args:
25143 
  """
25144 
  Attributes:
25145 
   - orderId
25146 
  """
25147 
 
25148 
  thrift_spec = (
25149 
    None, # 0
25150 
    (1, TType.I64, 'orderId', None, None, ), # 1
25151 
  )
25152 
 
25153 
  def __init__(self, orderId=None,):
25154 
    self.orderId = orderId
25155 
 
25156 
  def read(self, iprot):
25157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25159 
      return
25160 
    iprot.readStructBegin()
25161 
    while True:
25162 
      (fname, ftype, fid) = iprot.readFieldBegin()
25163 
      if ftype == TType.STOP:
25164 
        break
25165 
      if fid == 1:
25166 
        if ftype == TType.I64:
25167 
          self.orderId = iprot.readI64();
25168 
        else:
25169 
          iprot.skip(ftype)
25170 
      else:
25171 
        iprot.skip(ftype)
25172 
      iprot.readFieldEnd()
25173 
    iprot.readStructEnd()
25174 
 
25175 
  def write(self, oprot):
25176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25178 
      return
25179 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25180 
    if self.orderId is not None:
25181 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25182 
      oprot.writeI64(self.orderId)
25183 
      oprot.writeFieldEnd()
25184 
    oprot.writeFieldStop()
25185 
    oprot.writeStructEnd()
25186 
 
25187 
  def validate(self):
25188 
    return
25189 
 
25190 
 
25191 
  def __repr__(self):
25192 
    L = ['%s=%r' % (key, value)
25193 
      for key, value in self.__dict__.iteritems()]
25194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25195 
 
25196 
  def __eq__(self, other):
25197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25198 
 
25199 
  def __ne__(self, other):
25200 
    return not (self == other)
25201 
 
25202 
class updateOrderAsPaidToVendor_result:
25203 
  """
25204 
  Attributes:
25205 
   - ex
25206 
  """
25207 
 
25208 
  thrift_spec = (
25209 
    None, # 0
25210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25211 
  )
25212 
 
25213 
  def __init__(self, ex=None,):
25214 
    self.ex = ex
25215 
 
25216 
  def read(self, iprot):
25217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25219 
      return
25220 
    iprot.readStructBegin()
25221 
    while True:
25222 
      (fname, ftype, fid) = iprot.readFieldBegin()
25223 
      if ftype == TType.STOP:
25224 
        break
25225 
      if fid == 1:
25226 
        if ftype == TType.STRUCT:
25227 
          self.ex = TransactionServiceException()
25228 
          self.ex.read(iprot)
25229 
        else:
25230 
          iprot.skip(ftype)
25231 
      else:
25232 
        iprot.skip(ftype)
25233 
      iprot.readFieldEnd()
25234 
    iprot.readStructEnd()
25235 
 
25236 
  def write(self, oprot):
25237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25239 
      return
25240 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25241 
    if self.ex is not None:
25242 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25243 
      self.ex.write(oprot)
25244 
      oprot.writeFieldEnd()
25245 
    oprot.writeFieldStop()
25246 
    oprot.writeStructEnd()
25247 
 
25248 
  def validate(self):
25249 
    return
25250 
 
25251 
 
25252 
  def __repr__(self):
25253 
    L = ['%s=%r' % (key, value)
25254 
      for key, value in self.__dict__.iteritems()]
25255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25256 
 
25257 
  def __eq__(self, other):
25258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25259 
 
25260 
  def __ne__(self, other):
25261 
    return not (self == other)
5208 varun.gupt 25262 
 
5386 phani.kuma 25263 
class updateOrderOnlyAsPaidToVendor_args:
25264 
  """
25265 
  Attributes:
25266 
   - orderId
25267 
  """
25268 
 
25269 
  thrift_spec = (
25270 
    None, # 0
25271 
    (1, TType.I64, 'orderId', None, None, ), # 1
25272 
  )
25273 
 
25274 
  def __init__(self, orderId=None,):
25275 
    self.orderId = orderId
25276 
 
25277 
  def read(self, iprot):
25278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25280 
      return
25281 
    iprot.readStructBegin()
25282 
    while True:
25283 
      (fname, ftype, fid) = iprot.readFieldBegin()
25284 
      if ftype == TType.STOP:
25285 
        break
25286 
      if fid == 1:
25287 
        if ftype == TType.I64:
25288 
          self.orderId = iprot.readI64();
25289 
        else:
25290 
          iprot.skip(ftype)
25291 
      else:
25292 
        iprot.skip(ftype)
25293 
      iprot.readFieldEnd()
25294 
    iprot.readStructEnd()
25295 
 
25296 
  def write(self, oprot):
25297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25299 
      return
25300 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25301 
    if self.orderId is not None:
25302 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25303 
      oprot.writeI64(self.orderId)
25304 
      oprot.writeFieldEnd()
25305 
    oprot.writeFieldStop()
25306 
    oprot.writeStructEnd()
25307 
 
25308 
  def validate(self):
25309 
    return
25310 
 
25311 
 
25312 
  def __repr__(self):
25313 
    L = ['%s=%r' % (key, value)
25314 
      for key, value in self.__dict__.iteritems()]
25315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25316 
 
25317 
  def __eq__(self, other):
25318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25319 
 
25320 
  def __ne__(self, other):
25321 
    return not (self == other)
25322 
 
25323 
class updateOrderOnlyAsPaidToVendor_result:
25324 
  """
25325 
  Attributes:
25326 
   - ex
25327 
  """
25328 
 
25329 
  thrift_spec = (
25330 
    None, # 0
25331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25332 
  )
25333 
 
25334 
  def __init__(self, ex=None,):
25335 
    self.ex = ex
25336 
 
25337 
  def read(self, iprot):
25338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25340 
      return
25341 
    iprot.readStructBegin()
25342 
    while True:
25343 
      (fname, ftype, fid) = iprot.readFieldBegin()
25344 
      if ftype == TType.STOP:
25345 
        break
25346 
      if fid == 1:
25347 
        if ftype == TType.STRUCT:
25348 
          self.ex = TransactionServiceException()
25349 
          self.ex.read(iprot)
25350 
        else:
25351 
          iprot.skip(ftype)
25352 
      else:
25353 
        iprot.skip(ftype)
25354 
      iprot.readFieldEnd()
25355 
    iprot.readStructEnd()
25356 
 
25357 
  def write(self, oprot):
25358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25360 
      return
25361 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25362 
    if self.ex is not None:
25363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25364 
      self.ex.write(oprot)
25365 
      oprot.writeFieldEnd()
25366 
    oprot.writeFieldStop()
25367 
    oprot.writeStructEnd()
25368 
 
25369 
  def validate(self):
25370 
    return
25371 
 
25372 
 
25373 
  def __repr__(self):
25374 
    L = ['%s=%r' % (key, value)
25375 
      for key, value in self.__dict__.iteritems()]
25376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25377 
 
25378 
  def __eq__(self, other):
25379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25380 
 
25381 
  def __ne__(self, other):
25382 
    return not (self == other)
25383 
 
5208 varun.gupt 25384 
class getRefundedOrdersMarkedPaid_args:
25385 
 
25386 
  thrift_spec = (
25387 
  )
25388 
 
25389 
  def read(self, iprot):
25390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25392 
      return
25393 
    iprot.readStructBegin()
25394 
    while True:
25395 
      (fname, ftype, fid) = iprot.readFieldBegin()
25396 
      if ftype == TType.STOP:
25397 
        break
25398 
      else:
25399 
        iprot.skip(ftype)
25400 
      iprot.readFieldEnd()
25401 
    iprot.readStructEnd()
25402 
 
25403 
  def write(self, oprot):
25404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25406 
      return
25407 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25408 
    oprot.writeFieldStop()
25409 
    oprot.writeStructEnd()
25410 
 
25411 
  def validate(self):
25412 
    return
25413 
 
25414 
 
25415 
  def __repr__(self):
25416 
    L = ['%s=%r' % (key, value)
25417 
      for key, value in self.__dict__.iteritems()]
25418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25419 
 
25420 
  def __eq__(self, other):
25421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25422 
 
25423 
  def __ne__(self, other):
25424 
    return not (self == other)
25425 
 
25426 
class getRefundedOrdersMarkedPaid_result:
25427 
  """
25428 
  Attributes:
25429 
   - success
25430 
   - ex
25431 
  """
25432 
 
25433 
  thrift_spec = (
25434 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25436 
  )
25437 
 
25438 
  def __init__(self, success=None, ex=None,):
25439 
    self.success = success
25440 
    self.ex = ex
25441 
 
25442 
  def read(self, iprot):
25443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25445 
      return
25446 
    iprot.readStructBegin()
25447 
    while True:
25448 
      (fname, ftype, fid) = iprot.readFieldBegin()
25449 
      if ftype == TType.STOP:
25450 
        break
25451 
      if fid == 0:
25452 
        if ftype == TType.LIST:
25453 
          self.success = []
6188 rajveer 25454 
          (_etype610, _size607) = iprot.readListBegin()
25455 
          for _i611 in xrange(_size607):
25456 
            _elem612 = Order()
25457 
            _elem612.read(iprot)
25458 
            self.success.append(_elem612)
5208 varun.gupt 25459 
          iprot.readListEnd()
25460 
        else:
25461 
          iprot.skip(ftype)
25462 
      elif fid == 1:
25463 
        if ftype == TType.STRUCT:
25464 
          self.ex = TransactionServiceException()
25465 
          self.ex.read(iprot)
25466 
        else:
25467 
          iprot.skip(ftype)
25468 
      else:
25469 
        iprot.skip(ftype)
25470 
      iprot.readFieldEnd()
25471 
    iprot.readStructEnd()
25472 
 
25473 
  def write(self, oprot):
25474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25476 
      return
25477 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25478 
    if self.success is not None:
25479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25480 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25481 
      for iter613 in self.success:
25482 
        iter613.write(oprot)
5208 varun.gupt 25483 
      oprot.writeListEnd()
25484 
      oprot.writeFieldEnd()
25485 
    if self.ex is not None:
25486 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25487 
      self.ex.write(oprot)
25488 
      oprot.writeFieldEnd()
25489 
    oprot.writeFieldStop()
25490 
    oprot.writeStructEnd()
25491 
 
25492 
  def validate(self):
25493 
    return
25494 
 
25495 
 
25496 
  def __repr__(self):
25497 
    L = ['%s=%r' % (key, value)
25498 
      for key, value in self.__dict__.iteritems()]
25499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25500 
 
25501 
  def __eq__(self, other):
25502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25503 
 
25504 
  def __ne__(self, other):
25505 
    return not (self == other)
5447 anupam.sin 25506 
 
25507 
class getAllVerificationAgents_args:
25508 
  """
25509 
  Attributes:
25510 
   - minOrderId
25511 
   - maxOrderId
25512 
  """
25513 
 
25514 
  thrift_spec = (
25515 
    None, # 0
25516 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25517 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25518 
  )
25519 
 
25520 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25521 
    self.minOrderId = minOrderId
25522 
    self.maxOrderId = maxOrderId
25523 
 
25524 
  def read(self, iprot):
25525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25527 
      return
25528 
    iprot.readStructBegin()
25529 
    while True:
25530 
      (fname, ftype, fid) = iprot.readFieldBegin()
25531 
      if ftype == TType.STOP:
25532 
        break
25533 
      if fid == 1:
25534 
        if ftype == TType.I64:
25535 
          self.minOrderId = iprot.readI64();
25536 
        else:
25537 
          iprot.skip(ftype)
25538 
      elif fid == 2:
25539 
        if ftype == TType.I64:
25540 
          self.maxOrderId = iprot.readI64();
25541 
        else:
25542 
          iprot.skip(ftype)
25543 
      else:
25544 
        iprot.skip(ftype)
25545 
      iprot.readFieldEnd()
25546 
    iprot.readStructEnd()
25547 
 
25548 
  def write(self, oprot):
25549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25551 
      return
25552 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25553 
    if self.minOrderId is not None:
25554 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25555 
      oprot.writeI64(self.minOrderId)
25556 
      oprot.writeFieldEnd()
25557 
    if self.maxOrderId is not None:
25558 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25559 
      oprot.writeI64(self.maxOrderId)
25560 
      oprot.writeFieldEnd()
25561 
    oprot.writeFieldStop()
25562 
    oprot.writeStructEnd()
25563 
 
25564 
  def validate(self):
25565 
    return
25566 
 
25567 
 
25568 
  def __repr__(self):
25569 
    L = ['%s=%r' % (key, value)
25570 
      for key, value in self.__dict__.iteritems()]
25571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25572 
 
25573 
  def __eq__(self, other):
25574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25575 
 
25576 
  def __ne__(self, other):
25577 
    return not (self == other)
25578 
 
25579 
class getAllVerificationAgents_result:
25580 
  """
25581 
  Attributes:
25582 
   - success
25583 
  """
25584 
 
25585 
  thrift_spec = (
25586 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25587 
  )
25588 
 
25589 
  def __init__(self, success=None,):
25590 
    self.success = success
25591 
 
25592 
  def read(self, iprot):
25593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25595 
      return
25596 
    iprot.readStructBegin()
25597 
    while True:
25598 
      (fname, ftype, fid) = iprot.readFieldBegin()
25599 
      if ftype == TType.STOP:
25600 
        break
25601 
      if fid == 0:
25602 
        if ftype == TType.LIST:
25603 
          self.success = []
6188 rajveer 25604 
          (_etype617, _size614) = iprot.readListBegin()
25605 
          for _i618 in xrange(_size614):
25606 
            _elem619 = CODVerificationAgent()
25607 
            _elem619.read(iprot)
25608 
            self.success.append(_elem619)
5447 anupam.sin 25609 
          iprot.readListEnd()
25610 
        else:
25611 
          iprot.skip(ftype)
25612 
      else:
25613 
        iprot.skip(ftype)
25614 
      iprot.readFieldEnd()
25615 
    iprot.readStructEnd()
25616 
 
25617 
  def write(self, oprot):
25618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25620 
      return
25621 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25622 
    if self.success is not None:
25623 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25624 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25625 
      for iter620 in self.success:
25626 
        iter620.write(oprot)
5447 anupam.sin 25627 
      oprot.writeListEnd()
25628 
      oprot.writeFieldEnd()
25629 
    oprot.writeFieldStop()
25630 
    oprot.writeStructEnd()
25631 
 
25632 
  def validate(self):
25633 
    return
25634 
 
25635 
 
25636 
  def __repr__(self):
25637 
    L = ['%s=%r' % (key, value)
25638 
      for key, value in self.__dict__.iteritems()]
25639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25640 
 
25641 
  def __eq__(self, other):
25642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25643 
 
25644 
  def __ne__(self, other):
25645 
    return not (self == other)
5527 anupam.sin 25646 
 
25647 
class getAllAttributesForOrderId_args:
25648 
  """
25649 
  Attributes:
25650 
   - orderId
25651 
  """
25652 
 
25653 
  thrift_spec = (
25654 
    None, # 0
25655 
    (1, TType.I64, 'orderId', None, None, ), # 1
25656 
  )
25657 
 
25658 
  def __init__(self, orderId=None,):
25659 
    self.orderId = orderId
25660 
 
25661 
  def read(self, iprot):
25662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25664 
      return
25665 
    iprot.readStructBegin()
25666 
    while True:
25667 
      (fname, ftype, fid) = iprot.readFieldBegin()
25668 
      if ftype == TType.STOP:
25669 
        break
25670 
      if fid == 1:
25671 
        if ftype == TType.I64:
25672 
          self.orderId = iprot.readI64();
25673 
        else:
25674 
          iprot.skip(ftype)
25675 
      else:
25676 
        iprot.skip(ftype)
25677 
      iprot.readFieldEnd()
25678 
    iprot.readStructEnd()
25679 
 
25680 
  def write(self, oprot):
25681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25683 
      return
25684 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25685 
    if self.orderId is not None:
25686 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25687 
      oprot.writeI64(self.orderId)
25688 
      oprot.writeFieldEnd()
25689 
    oprot.writeFieldStop()
25690 
    oprot.writeStructEnd()
25691 
 
25692 
  def validate(self):
25693 
    return
25694 
 
25695 
 
25696 
  def __repr__(self):
25697 
    L = ['%s=%r' % (key, value)
25698 
      for key, value in self.__dict__.iteritems()]
25699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25700 
 
25701 
  def __eq__(self, other):
25702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25703 
 
25704 
  def __ne__(self, other):
25705 
    return not (self == other)
25706 
 
25707 
class getAllAttributesForOrderId_result:
25708 
  """
25709 
  Attributes:
25710 
   - success
25711 
  """
25712 
 
25713 
  thrift_spec = (
25714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25715 
  )
25716 
 
25717 
  def __init__(self, success=None,):
25718 
    self.success = success
25719 
 
25720 
  def read(self, iprot):
25721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25723 
      return
25724 
    iprot.readStructBegin()
25725 
    while True:
25726 
      (fname, ftype, fid) = iprot.readFieldBegin()
25727 
      if ftype == TType.STOP:
25728 
        break
25729 
      if fid == 0:
25730 
        if ftype == TType.LIST:
25731 
          self.success = []
6188 rajveer 25732 
          (_etype624, _size621) = iprot.readListBegin()
25733 
          for _i625 in xrange(_size621):
25734 
            _elem626 = Attribute()
25735 
            _elem626.read(iprot)
25736 
            self.success.append(_elem626)
5527 anupam.sin 25737 
          iprot.readListEnd()
25738 
        else:
25739 
          iprot.skip(ftype)
25740 
      else:
25741 
        iprot.skip(ftype)
25742 
      iprot.readFieldEnd()
25743 
    iprot.readStructEnd()
25744 
 
25745 
  def write(self, oprot):
25746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25748 
      return
25749 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25750 
    if self.success is not None:
25751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25753 
      for iter627 in self.success:
25754 
        iter627.write(oprot)
5527 anupam.sin 25755 
      oprot.writeListEnd()
25756 
      oprot.writeFieldEnd()
25757 
    oprot.writeFieldStop()
25758 
    oprot.writeStructEnd()
25759 
 
25760 
  def validate(self):
25761 
    return
25762 
 
25763 
 
25764 
  def __repr__(self):
25765 
    L = ['%s=%r' % (key, value)
25766 
      for key, value in self.__dict__.iteritems()]
25767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25768 
 
25769 
  def __eq__(self, other):
25770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25771 
 
25772 
  def __ne__(self, other):
25773 
    return not (self == other)
25774 
 
5676 rajveer 25775 
class setOrderAttributes_args:
25776 
  """
25777 
  Attributes:
25778 
   - orderId
25779 
   - attributes
25780 
  """
25781 
 
25782 
  thrift_spec = None
25783 
  def __init__(self, orderId=None, attributes=None,):
25784 
    self.orderId = orderId
25785 
    self.attributes = attributes
25786 
 
25787 
  def read(self, iprot):
25788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25790 
      return
25791 
    iprot.readStructBegin()
25792 
    while True:
25793 
      (fname, ftype, fid) = iprot.readFieldBegin()
25794 
      if ftype == TType.STOP:
25795 
        break
25796 
      if fid == 1:
25797 
        if ftype == TType.I64:
25798 
          self.orderId = iprot.readI64();
25799 
        else:
25800 
          iprot.skip(ftype)
25801 
      elif fid == -1:
25802 
        if ftype == TType.LIST:
25803 
          self.attributes = []
6188 rajveer 25804 
          (_etype631, _size628) = iprot.readListBegin()
25805 
          for _i632 in xrange(_size628):
25806 
            _elem633 = Attribute()
25807 
            _elem633.read(iprot)
25808 
            self.attributes.append(_elem633)
5676 rajveer 25809 
          iprot.readListEnd()
25810 
        else:
25811 
          iprot.skip(ftype)
25812 
      else:
25813 
        iprot.skip(ftype)
25814 
      iprot.readFieldEnd()
25815 
    iprot.readStructEnd()
25816 
 
25817 
  def write(self, oprot):
25818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25820 
      return
25821 
    oprot.writeStructBegin('setOrderAttributes_args')
25822 
    if self.attributes is not None:
25823 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25824 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25825 
      for iter634 in self.attributes:
25826 
        iter634.write(oprot)
5676 rajveer 25827 
      oprot.writeListEnd()
25828 
      oprot.writeFieldEnd()
25829 
    if self.orderId is not None:
25830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25831 
      oprot.writeI64(self.orderId)
25832 
      oprot.writeFieldEnd()
25833 
    oprot.writeFieldStop()
25834 
    oprot.writeStructEnd()
25835 
 
25836 
  def validate(self):
25837 
    return
25838 
 
25839 
 
25840 
  def __repr__(self):
25841 
    L = ['%s=%r' % (key, value)
25842 
      for key, value in self.__dict__.iteritems()]
25843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25844 
 
25845 
  def __eq__(self, other):
25846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25847 
 
25848 
  def __ne__(self, other):
25849 
    return not (self == other)
25850 
 
25851 
class setOrderAttributes_result:
25852 
 
25853 
  thrift_spec = (
25854 
  )
25855 
 
25856 
  def read(self, iprot):
25857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25859 
      return
25860 
    iprot.readStructBegin()
25861 
    while True:
25862 
      (fname, ftype, fid) = iprot.readFieldBegin()
25863 
      if ftype == TType.STOP:
25864 
        break
25865 
      else:
25866 
        iprot.skip(ftype)
25867 
      iprot.readFieldEnd()
25868 
    iprot.readStructEnd()
25869 
 
25870 
  def write(self, oprot):
25871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25873 
      return
25874 
    oprot.writeStructBegin('setOrderAttributes_result')
25875 
    oprot.writeFieldStop()
25876 
    oprot.writeStructEnd()
25877 
 
25878 
  def validate(self):
25879 
    return
25880 
 
25881 
 
25882 
  def __repr__(self):
25883 
    L = ['%s=%r' % (key, value)
25884 
      for key, value in self.__dict__.iteritems()]
25885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25886 
 
25887 
  def __eq__(self, other):
25888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25889 
 
25890 
  def __ne__(self, other):
25891 
    return not (self == other)
25892 
 
5527 anupam.sin 25893 
class setOrderAttributeForTransaction_args:
25894 
  """
25895 
  Attributes:
25896 
   - transactionId
25897 
   - attribute
25898 
  """
25899 
 
25900 
  thrift_spec = None
25901 
  def __init__(self, transactionId=None, attribute=None,):
25902 
    self.transactionId = transactionId
25903 
    self.attribute = attribute
25904 
 
25905 
  def read(self, iprot):
25906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25908 
      return
25909 
    iprot.readStructBegin()
25910 
    while True:
25911 
      (fname, ftype, fid) = iprot.readFieldBegin()
25912 
      if ftype == TType.STOP:
25913 
        break
25914 
      if fid == 1:
25915 
        if ftype == TType.I64:
25916 
          self.transactionId = iprot.readI64();
25917 
        else:
25918 
          iprot.skip(ftype)
25919 
      elif fid == -1:
25920 
        if ftype == TType.STRUCT:
25921 
          self.attribute = Attribute()
25922 
          self.attribute.read(iprot)
25923 
        else:
25924 
          iprot.skip(ftype)
25925 
      else:
25926 
        iprot.skip(ftype)
25927 
      iprot.readFieldEnd()
25928 
    iprot.readStructEnd()
25929 
 
25930 
  def write(self, oprot):
25931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25933 
      return
25934 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25935 
    if self.attribute is not None:
25936 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25937 
      self.attribute.write(oprot)
25938 
      oprot.writeFieldEnd()
25939 
    if self.transactionId is not None:
25940 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25941 
      oprot.writeI64(self.transactionId)
25942 
      oprot.writeFieldEnd()
25943 
    oprot.writeFieldStop()
25944 
    oprot.writeStructEnd()
25945 
 
25946 
  def validate(self):
25947 
    return
25948 
 
25949 
 
25950 
  def __repr__(self):
25951 
    L = ['%s=%r' % (key, value)
25952 
      for key, value in self.__dict__.iteritems()]
25953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25954 
 
25955 
  def __eq__(self, other):
25956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25957 
 
25958 
  def __ne__(self, other):
25959 
    return not (self == other)
25960 
 
25961 
class setOrderAttributeForTransaction_result:
25962 
 
25963 
  thrift_spec = (
25964 
  )
25965 
 
25966 
  def read(self, iprot):
25967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25969 
      return
25970 
    iprot.readStructBegin()
25971 
    while True:
25972 
      (fname, ftype, fid) = iprot.readFieldBegin()
25973 
      if ftype == TType.STOP:
25974 
        break
25975 
      else:
25976 
        iprot.skip(ftype)
25977 
      iprot.readFieldEnd()
25978 
    iprot.readStructEnd()
25979 
 
25980 
  def write(self, oprot):
25981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25983 
      return
25984 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25985 
    oprot.writeFieldStop()
25986 
    oprot.writeStructEnd()
25987 
 
25988 
  def validate(self):
25989 
    return
25990 
 
25991 
 
25992 
  def __repr__(self):
25993 
    L = ['%s=%r' % (key, value)
25994 
      for key, value in self.__dict__.iteritems()]
25995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25996 
 
25997 
  def __eq__(self, other):
25998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25999 
 
26000 
  def __ne__(self, other):
26001 
    return not (self == other)
5553 rajveer 26002 
 
26003 
class getReceivePendingOrders_args:
26004 
  """
26005 
  Attributes:
26006 
   - storeId
26007 
  """
26008 
 
26009 
  thrift_spec = (
26010 
    None, # 0
26011 
    (1, TType.I64, 'storeId', None, None, ), # 1
26012 
  )
26013 
 
26014 
  def __init__(self, storeId=None,):
26015 
    self.storeId = storeId
26016 
 
26017 
  def read(self, iprot):
26018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26020 
      return
26021 
    iprot.readStructBegin()
26022 
    while True:
26023 
      (fname, ftype, fid) = iprot.readFieldBegin()
26024 
      if ftype == TType.STOP:
26025 
        break
26026 
      if fid == 1:
26027 
        if ftype == TType.I64:
26028 
          self.storeId = iprot.readI64();
26029 
        else:
26030 
          iprot.skip(ftype)
26031 
      else:
26032 
        iprot.skip(ftype)
26033 
      iprot.readFieldEnd()
26034 
    iprot.readStructEnd()
26035 
 
26036 
  def write(self, oprot):
26037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26039 
      return
26040 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26041 
    if self.storeId is not None:
26042 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26043 
      oprot.writeI64(self.storeId)
26044 
      oprot.writeFieldEnd()
26045 
    oprot.writeFieldStop()
26046 
    oprot.writeStructEnd()
26047 
 
26048 
  def validate(self):
26049 
    return
26050 
 
26051 
 
26052 
  def __repr__(self):
26053 
    L = ['%s=%r' % (key, value)
26054 
      for key, value in self.__dict__.iteritems()]
26055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26056 
 
26057 
  def __eq__(self, other):
26058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26059 
 
26060 
  def __ne__(self, other):
26061 
    return not (self == other)
26062 
 
26063 
class getReceivePendingOrders_result:
26064 
  """
26065 
  Attributes:
26066 
   - success
26067 
  """
26068 
 
26069 
  thrift_spec = (
26070 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26071 
  )
26072 
 
26073 
  def __init__(self, success=None,):
26074 
    self.success = success
26075 
 
26076 
  def read(self, iprot):
26077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26079 
      return
26080 
    iprot.readStructBegin()
26081 
    while True:
26082 
      (fname, ftype, fid) = iprot.readFieldBegin()
26083 
      if ftype == TType.STOP:
26084 
        break
26085 
      if fid == 0:
26086 
        if ftype == TType.LIST:
26087 
          self.success = []
6188 rajveer 26088 
          (_etype638, _size635) = iprot.readListBegin()
26089 
          for _i639 in xrange(_size635):
26090 
            _elem640 = Order()
26091 
            _elem640.read(iprot)
26092 
            self.success.append(_elem640)
5553 rajveer 26093 
          iprot.readListEnd()
26094 
        else:
26095 
          iprot.skip(ftype)
26096 
      else:
26097 
        iprot.skip(ftype)
26098 
      iprot.readFieldEnd()
26099 
    iprot.readStructEnd()
26100 
 
26101 
  def write(self, oprot):
26102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26104 
      return
26105 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26106 
    if self.success is not None:
26107 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26108 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26109 
      for iter641 in self.success:
26110 
        iter641.write(oprot)
5553 rajveer 26111 
      oprot.writeListEnd()
26112 
      oprot.writeFieldEnd()
26113 
    oprot.writeFieldStop()
26114 
    oprot.writeStructEnd()
26115 
 
26116 
  def validate(self):
26117 
    return
26118 
 
26119 
 
26120 
  def __repr__(self):
26121 
    L = ['%s=%r' % (key, value)
26122 
      for key, value in self.__dict__.iteritems()]
26123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26124 
 
26125 
  def __eq__(self, other):
26126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26127 
 
26128 
  def __ne__(self, other):
26129 
    return not (self == other)
26130 
 
26131 
class getReceivedAtStoreOrders_args:
26132 
  """
26133 
  Attributes:
26134 
   - storeId
26135 
  """
26136 
 
26137 
  thrift_spec = (
26138 
    None, # 0
26139 
    (1, TType.I64, 'storeId', None, None, ), # 1
26140 
  )
26141 
 
26142 
  def __init__(self, storeId=None,):
26143 
    self.storeId = storeId
26144 
 
26145 
  def read(self, iprot):
26146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26148 
      return
26149 
    iprot.readStructBegin()
26150 
    while True:
26151 
      (fname, ftype, fid) = iprot.readFieldBegin()
26152 
      if ftype == TType.STOP:
26153 
        break
26154 
      if fid == 1:
26155 
        if ftype == TType.I64:
26156 
          self.storeId = iprot.readI64();
26157 
        else:
26158 
          iprot.skip(ftype)
26159 
      else:
26160 
        iprot.skip(ftype)
26161 
      iprot.readFieldEnd()
26162 
    iprot.readStructEnd()
26163 
 
26164 
  def write(self, oprot):
26165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26167 
      return
26168 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26169 
    if self.storeId is not None:
26170 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26171 
      oprot.writeI64(self.storeId)
26172 
      oprot.writeFieldEnd()
26173 
    oprot.writeFieldStop()
26174 
    oprot.writeStructEnd()
26175 
 
26176 
  def validate(self):
26177 
    return
26178 
 
26179 
 
26180 
  def __repr__(self):
26181 
    L = ['%s=%r' % (key, value)
26182 
      for key, value in self.__dict__.iteritems()]
26183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26184 
 
26185 
  def __eq__(self, other):
26186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26187 
 
26188 
  def __ne__(self, other):
26189 
    return not (self == other)
26190 
 
26191 
class getReceivedAtStoreOrders_result:
26192 
  """
26193 
  Attributes:
26194 
   - success
26195 
  """
26196 
 
26197 
  thrift_spec = (
26198 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26199 
  )
26200 
 
26201 
  def __init__(self, success=None,):
26202 
    self.success = success
26203 
 
26204 
  def read(self, iprot):
26205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26207 
      return
26208 
    iprot.readStructBegin()
26209 
    while True:
26210 
      (fname, ftype, fid) = iprot.readFieldBegin()
26211 
      if ftype == TType.STOP:
26212 
        break
26213 
      if fid == 0:
26214 
        if ftype == TType.LIST:
26215 
          self.success = []
6188 rajveer 26216 
          (_etype645, _size642) = iprot.readListBegin()
26217 
          for _i646 in xrange(_size642):
26218 
            _elem647 = Order()
26219 
            _elem647.read(iprot)
26220 
            self.success.append(_elem647)
5553 rajveer 26221 
          iprot.readListEnd()
26222 
        else:
26223 
          iprot.skip(ftype)
26224 
      else:
26225 
        iprot.skip(ftype)
26226 
      iprot.readFieldEnd()
26227 
    iprot.readStructEnd()
26228 
 
26229 
  def write(self, oprot):
26230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26232 
      return
26233 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26234 
    if self.success is not None:
26235 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26236 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26237 
      for iter648 in self.success:
26238 
        iter648.write(oprot)
5553 rajveer 26239 
      oprot.writeListEnd()
26240 
      oprot.writeFieldEnd()
26241 
    oprot.writeFieldStop()
26242 
    oprot.writeStructEnd()
26243 
 
26244 
  def validate(self):
26245 
    return
26246 
 
26247 
 
26248 
  def __repr__(self):
26249 
    L = ['%s=%r' % (key, value)
26250 
      for key, value in self.__dict__.iteritems()]
26251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26252 
 
26253 
  def __eq__(self, other):
26254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26255 
 
26256 
  def __ne__(self, other):
26257 
    return not (self == other)
5593 mandeep.dh 26258 
 
5713 rajveer 26259 
class getOrdersCollectionAtStore_args:
26260 
  """
26261 
  Attributes:
26262 
   - storeId
26263 
   - fromDate
26264 
   - toDate
26265 
   - onlyCod
26266 
  """
26267 
 
26268 
  thrift_spec = (
26269 
    None, # 0
26270 
    (1, TType.I64, 'storeId', None, None, ), # 1
26271 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26272 
    (3, TType.I64, 'toDate', None, None, ), # 3
26273 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26274 
  )
26275 
 
26276 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26277 
    self.storeId = storeId
26278 
    self.fromDate = fromDate
26279 
    self.toDate = toDate
26280 
    self.onlyCod = onlyCod
26281 
 
26282 
  def read(self, iprot):
26283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26285 
      return
26286 
    iprot.readStructBegin()
26287 
    while True:
26288 
      (fname, ftype, fid) = iprot.readFieldBegin()
26289 
      if ftype == TType.STOP:
26290 
        break
26291 
      if fid == 1:
26292 
        if ftype == TType.I64:
26293 
          self.storeId = iprot.readI64();
26294 
        else:
26295 
          iprot.skip(ftype)
26296 
      elif fid == 2:
26297 
        if ftype == TType.I64:
26298 
          self.fromDate = iprot.readI64();
26299 
        else:
26300 
          iprot.skip(ftype)
26301 
      elif fid == 3:
26302 
        if ftype == TType.I64:
26303 
          self.toDate = iprot.readI64();
26304 
        else:
26305 
          iprot.skip(ftype)
26306 
      elif fid == 4:
26307 
        if ftype == TType.BOOL:
26308 
          self.onlyCod = iprot.readBool();
26309 
        else:
26310 
          iprot.skip(ftype)
26311 
      else:
26312 
        iprot.skip(ftype)
26313 
      iprot.readFieldEnd()
26314 
    iprot.readStructEnd()
26315 
 
26316 
  def write(self, oprot):
26317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26319 
      return
26320 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26321 
    if self.storeId is not None:
26322 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26323 
      oprot.writeI64(self.storeId)
26324 
      oprot.writeFieldEnd()
26325 
    if self.fromDate is not None:
26326 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26327 
      oprot.writeI64(self.fromDate)
26328 
      oprot.writeFieldEnd()
26329 
    if self.toDate is not None:
26330 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26331 
      oprot.writeI64(self.toDate)
26332 
      oprot.writeFieldEnd()
26333 
    if self.onlyCod is not None:
26334 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26335 
      oprot.writeBool(self.onlyCod)
26336 
      oprot.writeFieldEnd()
26337 
    oprot.writeFieldStop()
26338 
    oprot.writeStructEnd()
26339 
 
26340 
  def validate(self):
26341 
    return
26342 
 
26343 
 
26344 
  def __repr__(self):
26345 
    L = ['%s=%r' % (key, value)
26346 
      for key, value in self.__dict__.iteritems()]
26347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26348 
 
26349 
  def __eq__(self, other):
26350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26351 
 
26352 
  def __ne__(self, other):
26353 
    return not (self == other)
26354 
 
26355 
class getOrdersCollectionAtStore_result:
26356 
  """
26357 
  Attributes:
26358 
   - success
26359 
  """
26360 
 
26361 
  thrift_spec = (
26362 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26363 
  )
26364 
 
26365 
  def __init__(self, success=None,):
26366 
    self.success = success
26367 
 
26368 
  def read(self, iprot):
26369 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26370 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26371 
      return
26372 
    iprot.readStructBegin()
26373 
    while True:
26374 
      (fname, ftype, fid) = iprot.readFieldBegin()
26375 
      if ftype == TType.STOP:
26376 
        break
26377 
      if fid == 0:
26378 
        if ftype == TType.LIST:
26379 
          self.success = []
6188 rajveer 26380 
          (_etype652, _size649) = iprot.readListBegin()
26381 
          for _i653 in xrange(_size649):
26382 
            _elem654 = Order()
26383 
            _elem654.read(iprot)
26384 
            self.success.append(_elem654)
5713 rajveer 26385 
          iprot.readListEnd()
26386 
        else:
26387 
          iprot.skip(ftype)
26388 
      else:
26389 
        iprot.skip(ftype)
26390 
      iprot.readFieldEnd()
26391 
    iprot.readStructEnd()
26392 
 
26393 
  def write(self, oprot):
26394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26396 
      return
26397 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26398 
    if self.success is not None:
26399 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26400 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26401 
      for iter655 in self.success:
26402 
        iter655.write(oprot)
5713 rajveer 26403 
      oprot.writeListEnd()
26404 
      oprot.writeFieldEnd()
26405 
    oprot.writeFieldStop()
26406 
    oprot.writeStructEnd()
26407 
 
26408 
  def validate(self):
26409 
    return
26410 
 
26411 
 
26412 
  def __repr__(self):
26413 
    L = ['%s=%r' % (key, value)
26414 
      for key, value in self.__dict__.iteritems()]
26415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26416 
 
26417 
  def __eq__(self, other):
26418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26419 
 
26420 
  def __ne__(self, other):
26421 
    return not (self == other)
26422 
 
5833 rajveer 26423 
class getOrderAttributeValue_args:
26424 
  """
26425 
  Attributes:
26426 
   - orderId
26427 
   - attributeName
26428 
  """
26429 
 
26430 
  thrift_spec = None
26431 
  def __init__(self, orderId=None, attributeName=None,):
26432 
    self.orderId = orderId
26433 
    self.attributeName = attributeName
26434 
 
26435 
  def read(self, iprot):
26436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26438 
      return
26439 
    iprot.readStructBegin()
26440 
    while True:
26441 
      (fname, ftype, fid) = iprot.readFieldBegin()
26442 
      if ftype == TType.STOP:
26443 
        break
26444 
      if fid == 1:
26445 
        if ftype == TType.I64:
26446 
          self.orderId = iprot.readI64();
26447 
        else:
26448 
          iprot.skip(ftype)
26449 
      elif fid == -1:
26450 
        if ftype == TType.STRING:
26451 
          self.attributeName = iprot.readString();
26452 
        else:
26453 
          iprot.skip(ftype)
26454 
      else:
26455 
        iprot.skip(ftype)
26456 
      iprot.readFieldEnd()
26457 
    iprot.readStructEnd()
26458 
 
26459 
  def write(self, oprot):
26460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26462 
      return
26463 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26464 
    if self.attributeName is not None:
26465 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26466 
      oprot.writeString(self.attributeName)
26467 
      oprot.writeFieldEnd()
26468 
    if self.orderId is not None:
26469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26470 
      oprot.writeI64(self.orderId)
26471 
      oprot.writeFieldEnd()
26472 
    oprot.writeFieldStop()
26473 
    oprot.writeStructEnd()
26474 
 
26475 
  def validate(self):
26476 
    return
26477 
 
26478 
 
26479 
  def __repr__(self):
26480 
    L = ['%s=%r' % (key, value)
26481 
      for key, value in self.__dict__.iteritems()]
26482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26483 
 
26484 
  def __eq__(self, other):
26485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26486 
 
26487 
  def __ne__(self, other):
26488 
    return not (self == other)
26489 
 
26490 
class getOrderAttributeValue_result:
26491 
  """
26492 
  Attributes:
26493 
   - success
26494 
  """
26495 
 
26496 
  thrift_spec = (
26497 
    (0, TType.STRING, 'success', None, None, ), # 0
26498 
  )
26499 
 
26500 
  def __init__(self, success=None,):
26501 
    self.success = success
26502 
 
26503 
  def read(self, iprot):
26504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26506 
      return
26507 
    iprot.readStructBegin()
26508 
    while True:
26509 
      (fname, ftype, fid) = iprot.readFieldBegin()
26510 
      if ftype == TType.STOP:
26511 
        break
26512 
      if fid == 0:
26513 
        if ftype == TType.STRING:
26514 
          self.success = iprot.readString();
26515 
        else:
26516 
          iprot.skip(ftype)
26517 
      else:
26518 
        iprot.skip(ftype)
26519 
      iprot.readFieldEnd()
26520 
    iprot.readStructEnd()
26521 
 
26522 
  def write(self, oprot):
26523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26525 
      return
26526 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26527 
    if self.success is not None:
26528 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26529 
      oprot.writeString(self.success)
26530 
      oprot.writeFieldEnd()
26531 
    oprot.writeFieldStop()
26532 
    oprot.writeStructEnd()
26533 
 
26534 
  def validate(self):
26535 
    return
26536 
 
26537 
 
26538 
  def __repr__(self):
26539 
    L = ['%s=%r' % (key, value)
26540 
      for key, value in self.__dict__.iteritems()]
26541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26542 
 
26543 
  def __eq__(self, other):
26544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26545 
 
26546 
  def __ne__(self, other):
26547 
    return not (self == other)
26548 
 
6019 rajveer 26549 
class changeJacketNumber_args:
26550 
  """
26551 
  Attributes:
26552 
   - orderId
26553 
   - jacketNumber
26554 
  """
26555 
 
26556 
  thrift_spec = (
26557 
    None, # 0
26558 
    (1, TType.I64, 'orderId', None, None, ), # 1
26559 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26560 
  )
26561 
 
26562 
  def __init__(self, orderId=None, jacketNumber=None,):
26563 
    self.orderId = orderId
26564 
    self.jacketNumber = jacketNumber
26565 
 
26566 
  def read(self, iprot):
26567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26569 
      return
26570 
    iprot.readStructBegin()
26571 
    while True:
26572 
      (fname, ftype, fid) = iprot.readFieldBegin()
26573 
      if ftype == TType.STOP:
26574 
        break
26575 
      if fid == 1:
26576 
        if ftype == TType.I64:
26577 
          self.orderId = iprot.readI64();
26578 
        else:
26579 
          iprot.skip(ftype)
26580 
      elif fid == 2:
26581 
        if ftype == TType.I64:
26582 
          self.jacketNumber = iprot.readI64();
26583 
        else:
26584 
          iprot.skip(ftype)
26585 
      else:
26586 
        iprot.skip(ftype)
26587 
      iprot.readFieldEnd()
26588 
    iprot.readStructEnd()
26589 
 
26590 
  def write(self, oprot):
26591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26593 
      return
26594 
    oprot.writeStructBegin('changeJacketNumber_args')
26595 
    if self.orderId is not None:
26596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26597 
      oprot.writeI64(self.orderId)
26598 
      oprot.writeFieldEnd()
26599 
    if self.jacketNumber is not None:
26600 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26601 
      oprot.writeI64(self.jacketNumber)
26602 
      oprot.writeFieldEnd()
26603 
    oprot.writeFieldStop()
26604 
    oprot.writeStructEnd()
26605 
 
26606 
  def validate(self):
26607 
    return
26608 
 
26609 
 
26610 
  def __repr__(self):
26611 
    L = ['%s=%r' % (key, value)
26612 
      for key, value in self.__dict__.iteritems()]
26613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26614 
 
26615 
  def __eq__(self, other):
26616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26617 
 
26618 
  def __ne__(self, other):
26619 
    return not (self == other)
26620 
 
26621 
class changeJacketNumber_result:
26622 
  """
26623 
  Attributes:
26624 
   - success
26625 
  """
26626 
 
26627 
  thrift_spec = (
26628 
    (0, TType.BOOL, 'success', None, None, ), # 0
26629 
  )
26630 
 
26631 
  def __init__(self, success=None,):
26632 
    self.success = success
26633 
 
26634 
  def read(self, iprot):
26635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26637 
      return
26638 
    iprot.readStructBegin()
26639 
    while True:
26640 
      (fname, ftype, fid) = iprot.readFieldBegin()
26641 
      if ftype == TType.STOP:
26642 
        break
26643 
      if fid == 0:
26644 
        if ftype == TType.BOOL:
26645 
          self.success = iprot.readBool();
26646 
        else:
26647 
          iprot.skip(ftype)
26648 
      else:
26649 
        iprot.skip(ftype)
26650 
      iprot.readFieldEnd()
26651 
    iprot.readStructEnd()
26652 
 
26653 
  def write(self, oprot):
26654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26656 
      return
26657 
    oprot.writeStructBegin('changeJacketNumber_result')
26658 
    if self.success is not None:
26659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26660 
      oprot.writeBool(self.success)
26661 
      oprot.writeFieldEnd()
26662 
    oprot.writeFieldStop()
26663 
    oprot.writeStructEnd()
26664 
 
26665 
  def validate(self):
26666 
    return
26667 
 
26668 
 
26669 
  def __repr__(self):
26670 
    L = ['%s=%r' % (key, value)
26671 
      for key, value in self.__dict__.iteritems()]
26672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26673 
 
26674 
  def __eq__(self, other):
26675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26676 
 
26677 
  def __ne__(self, other):
26678 
    return not (self == other)
26679 
 
26680 
class markOrderAsRtoInTransit_args:
26681 
  """
26682 
  Attributes:
26683 
   - orderId
26684 
  """
26685 
 
26686 
  thrift_spec = (
26687 
    None, # 0
26688 
    (1, TType.I64, 'orderId', None, None, ), # 1
26689 
  )
26690 
 
26691 
  def __init__(self, orderId=None,):
26692 
    self.orderId = orderId
26693 
 
26694 
  def read(self, iprot):
26695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26697 
      return
26698 
    iprot.readStructBegin()
26699 
    while True:
26700 
      (fname, ftype, fid) = iprot.readFieldBegin()
26701 
      if ftype == TType.STOP:
26702 
        break
26703 
      if fid == 1:
26704 
        if ftype == TType.I64:
26705 
          self.orderId = iprot.readI64();
26706 
        else:
26707 
          iprot.skip(ftype)
26708 
      else:
26709 
        iprot.skip(ftype)
26710 
      iprot.readFieldEnd()
26711 
    iprot.readStructEnd()
26712 
 
26713 
  def write(self, oprot):
26714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26716 
      return
26717 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26718 
    if self.orderId is not None:
26719 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26720 
      oprot.writeI64(self.orderId)
26721 
      oprot.writeFieldEnd()
26722 
    oprot.writeFieldStop()
26723 
    oprot.writeStructEnd()
26724 
 
26725 
  def validate(self):
26726 
    return
26727 
 
26728 
 
26729 
  def __repr__(self):
26730 
    L = ['%s=%r' % (key, value)
26731 
      for key, value in self.__dict__.iteritems()]
26732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26733 
 
26734 
  def __eq__(self, other):
26735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26736 
 
26737 
  def __ne__(self, other):
26738 
    return not (self == other)
26739 
 
26740 
class markOrderAsRtoInTransit_result:
26741 
  """
26742 
  Attributes:
26743 
   - success
26744 
  """
26745 
 
26746 
  thrift_spec = (
26747 
    (0, TType.BOOL, 'success', None, None, ), # 0
26748 
  )
26749 
 
26750 
  def __init__(self, success=None,):
26751 
    self.success = success
26752 
 
26753 
  def read(self, iprot):
26754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26756 
      return
26757 
    iprot.readStructBegin()
26758 
    while True:
26759 
      (fname, ftype, fid) = iprot.readFieldBegin()
26760 
      if ftype == TType.STOP:
26761 
        break
26762 
      if fid == 0:
26763 
        if ftype == TType.BOOL:
26764 
          self.success = iprot.readBool();
26765 
        else:
26766 
          iprot.skip(ftype)
26767 
      else:
26768 
        iprot.skip(ftype)
26769 
      iprot.readFieldEnd()
26770 
    iprot.readStructEnd()
26771 
 
26772 
  def write(self, oprot):
26773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26775 
      return
26776 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26777 
    if self.success is not None:
26778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26779 
      oprot.writeBool(self.success)
26780 
      oprot.writeFieldEnd()
26781 
    oprot.writeFieldStop()
26782 
    oprot.writeStructEnd()
26783 
 
26784 
  def validate(self):
26785 
    return
26786 
 
26787 
 
26788 
  def __repr__(self):
26789 
    L = ['%s=%r' % (key, value)
26790 
      for key, value in self.__dict__.iteritems()]
26791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26792 
 
26793 
  def __eq__(self, other):
26794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26795 
 
26796 
  def __ne__(self, other):
26797 
    return not (self == other)
26798 
 
5593 mandeep.dh 26799 
class acceptOrderForItem_args:
26800 
  """
26801 
  Attributes:
26802 
   - itemId
26803 
   - quantity
26804 
   - fulfilmentWarehouseId
26805 
   - billingWarehouseId
26806 
  """
26807 
 
26808 
  thrift_spec = (
26809 
    None, # 0
26810 
    (1, TType.I64, 'itemId', None, None, ), # 1
26811 
    (2, TType.I64, 'quantity', None, None, ), # 2
26812 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26813 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26814 
  )
26815 
 
26816 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26817 
    self.itemId = itemId
26818 
    self.quantity = quantity
26819 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26820 
    self.billingWarehouseId = billingWarehouseId
26821 
 
26822 
  def read(self, iprot):
26823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26825 
      return
26826 
    iprot.readStructBegin()
26827 
    while True:
26828 
      (fname, ftype, fid) = iprot.readFieldBegin()
26829 
      if ftype == TType.STOP:
26830 
        break
26831 
      if fid == 1:
26832 
        if ftype == TType.I64:
26833 
          self.itemId = iprot.readI64();
26834 
        else:
26835 
          iprot.skip(ftype)
26836 
      elif fid == 2:
26837 
        if ftype == TType.I64:
26838 
          self.quantity = iprot.readI64();
26839 
        else:
26840 
          iprot.skip(ftype)
26841 
      elif fid == 3:
26842 
        if ftype == TType.I64:
26843 
          self.fulfilmentWarehouseId = iprot.readI64();
26844 
        else:
26845 
          iprot.skip(ftype)
26846 
      elif fid == 4:
26847 
        if ftype == TType.I64:
26848 
          self.billingWarehouseId = iprot.readI64();
26849 
        else:
26850 
          iprot.skip(ftype)
26851 
      else:
26852 
        iprot.skip(ftype)
26853 
      iprot.readFieldEnd()
26854 
    iprot.readStructEnd()
26855 
 
26856 
  def write(self, oprot):
26857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26859 
      return
26860 
    oprot.writeStructBegin('acceptOrderForItem_args')
26861 
    if self.itemId is not None:
26862 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26863 
      oprot.writeI64(self.itemId)
26864 
      oprot.writeFieldEnd()
26865 
    if self.quantity is not None:
26866 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26867 
      oprot.writeI64(self.quantity)
26868 
      oprot.writeFieldEnd()
26869 
    if self.fulfilmentWarehouseId is not None:
26870 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26871 
      oprot.writeI64(self.fulfilmentWarehouseId)
26872 
      oprot.writeFieldEnd()
26873 
    if self.billingWarehouseId is not None:
26874 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26875 
      oprot.writeI64(self.billingWarehouseId)
26876 
      oprot.writeFieldEnd()
26877 
    oprot.writeFieldStop()
26878 
    oprot.writeStructEnd()
26879 
 
26880 
  def validate(self):
26881 
    return
26882 
 
26883 
 
26884 
  def __repr__(self):
26885 
    L = ['%s=%r' % (key, value)
26886 
      for key, value in self.__dict__.iteritems()]
26887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26888 
 
26889 
  def __eq__(self, other):
26890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26891 
 
26892 
  def __ne__(self, other):
26893 
    return not (self == other)
26894 
 
26895 
class acceptOrderForItem_result:
26896 
 
26897 
  thrift_spec = (
26898 
  )
26899 
 
26900 
  def read(self, iprot):
26901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26903 
      return
26904 
    iprot.readStructBegin()
26905 
    while True:
26906 
      (fname, ftype, fid) = iprot.readFieldBegin()
26907 
      if ftype == TType.STOP:
26908 
        break
26909 
      else:
26910 
        iprot.skip(ftype)
26911 
      iprot.readFieldEnd()
26912 
    iprot.readStructEnd()
26913 
 
26914 
  def write(self, oprot):
26915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26917 
      return
26918 
    oprot.writeStructBegin('acceptOrderForItem_result')
26919 
    oprot.writeFieldStop()
26920 
    oprot.writeStructEnd()
26921 
 
26922 
  def validate(self):
26923 
    return
26924 
 
26925 
 
26926 
  def __repr__(self):
26927 
    L = ['%s=%r' % (key, value)
26928 
      for key, value in self.__dict__.iteritems()]
26929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26930 
 
26931 
  def __eq__(self, other):
26932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26933 
 
26934 
  def __ne__(self, other):
26935 
    return not (self == other)
6000 mandeep.dh 26936 
 
26937 
class createRechargeOrder_args:
26938 
  """
26939 
  Attributes:
26940 
   - rechargeOrder
26941 
  """
26942 
 
26943 
  thrift_spec = (
26944 
    None, # 0
26945 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26946 
  )
26947 
 
26948 
  def __init__(self, rechargeOrder=None,):
26949 
    self.rechargeOrder = rechargeOrder
26950 
 
26951 
  def read(self, iprot):
26952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26954 
      return
26955 
    iprot.readStructBegin()
26956 
    while True:
26957 
      (fname, ftype, fid) = iprot.readFieldBegin()
26958 
      if ftype == TType.STOP:
26959 
        break
26960 
      if fid == 1:
26961 
        if ftype == TType.STRUCT:
26962 
          self.rechargeOrder = RechargeOrder()
26963 
          self.rechargeOrder.read(iprot)
26964 
        else:
26965 
          iprot.skip(ftype)
26966 
      else:
26967 
        iprot.skip(ftype)
26968 
      iprot.readFieldEnd()
26969 
    iprot.readStructEnd()
26970 
 
26971 
  def write(self, oprot):
26972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26974 
      return
26975 
    oprot.writeStructBegin('createRechargeOrder_args')
26976 
    if self.rechargeOrder is not None:
26977 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26978 
      self.rechargeOrder.write(oprot)
26979 
      oprot.writeFieldEnd()
26980 
    oprot.writeFieldStop()
26981 
    oprot.writeStructEnd()
26982 
 
26983 
  def validate(self):
26984 
    return
26985 
 
26986 
 
26987 
  def __repr__(self):
26988 
    L = ['%s=%r' % (key, value)
26989 
      for key, value in self.__dict__.iteritems()]
26990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26991 
 
26992 
  def __eq__(self, other):
26993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26994 
 
26995 
  def __ne__(self, other):
26996 
    return not (self == other)
26997 
 
26998 
class createRechargeOrder_result:
26999 
  """
27000 
  Attributes:
27001 
   - success
27002 
   - ex
27003 
  """
27004 
 
27005 
  thrift_spec = (
27006 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27008 
  )
27009 
 
27010 
  def __init__(self, success=None, ex=None,):
27011 
    self.success = success
27012 
    self.ex = ex
27013 
 
27014 
  def read(self, iprot):
27015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27017 
      return
27018 
    iprot.readStructBegin()
27019 
    while True:
27020 
      (fname, ftype, fid) = iprot.readFieldBegin()
27021 
      if ftype == TType.STOP:
27022 
        break
27023 
      if fid == 0:
27024 
        if ftype == TType.STRUCT:
27025 
          self.success = RechargeOrder()
27026 
          self.success.read(iprot)
27027 
        else:
27028 
          iprot.skip(ftype)
27029 
      elif fid == 1:
27030 
        if ftype == TType.STRUCT:
27031 
          self.ex = TransactionServiceException()
27032 
          self.ex.read(iprot)
27033 
        else:
27034 
          iprot.skip(ftype)
27035 
      else:
27036 
        iprot.skip(ftype)
27037 
      iprot.readFieldEnd()
27038 
    iprot.readStructEnd()
27039 
 
27040 
  def write(self, oprot):
27041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27043 
      return
27044 
    oprot.writeStructBegin('createRechargeOrder_result')
27045 
    if self.success is not None:
27046 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27047 
      self.success.write(oprot)
27048 
      oprot.writeFieldEnd()
27049 
    if self.ex is not None:
27050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27051 
      self.ex.write(oprot)
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 getRechargeOrder_args:
27072 
  """
27073 
  Attributes:
27074 
   - rechargeRrderId
27075 
  """
27076 
 
27077 
  thrift_spec = (
27078 
    None, # 0
27079 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27080 
  )
27081 
 
27082 
  def __init__(self, rechargeRrderId=None,):
27083 
    self.rechargeRrderId = rechargeRrderId
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:
27096 
          self.rechargeRrderId = iprot.readI64();
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
27108 
    oprot.writeStructBegin('getRechargeOrder_args')
27109 
    if self.rechargeRrderId is not None:
27110 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27111 
      oprot.writeI64(self.rechargeRrderId)
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 
 
27131 
class getRechargeOrder_result:
27132 
  """
27133 
  Attributes:
27134 
   - success
27135 
   - ex
27136 
  """
27137 
 
27138 
  thrift_spec = (
27139 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27141 
  )
27142 
 
27143 
  def __init__(self, success=None, ex=None,):
27144 
    self.success = success
27145 
    self.ex = ex
27146 
 
27147 
  def read(self, iprot):
27148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27150 
      return
27151 
    iprot.readStructBegin()
27152 
    while True:
27153 
      (fname, ftype, fid) = iprot.readFieldBegin()
27154 
      if ftype == TType.STOP:
27155 
        break
27156 
      if fid == 0:
27157 
        if ftype == TType.STRUCT:
27158 
          self.success = RechargeOrder()
27159 
          self.success.read(iprot)
27160 
        else:
27161 
          iprot.skip(ftype)
27162 
      elif fid == 1:
27163 
        if ftype == TType.STRUCT:
27164 
          self.ex = TransactionServiceException()
27165 
          self.ex.read(iprot)
27166 
        else:
27167 
          iprot.skip(ftype)
27168 
      else:
27169 
        iprot.skip(ftype)
27170 
      iprot.readFieldEnd()
27171 
    iprot.readStructEnd()
27172 
 
27173 
  def write(self, oprot):
27174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27176 
      return
27177 
    oprot.writeStructBegin('getRechargeOrder_result')
27178 
    if self.success is not None:
27179 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27180 
      self.success.write(oprot)
27181 
      oprot.writeFieldEnd()
27182 
    if self.ex is not None:
27183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27184 
      self.ex.write(oprot)
27185 
      oprot.writeFieldEnd()
27186 
    oprot.writeFieldStop()
27187 
    oprot.writeStructEnd()
27188 
 
27189 
  def validate(self):
27190 
    return
27191 
 
27192 
 
27193 
  def __repr__(self):
27194 
    L = ['%s=%r' % (key, value)
27195 
      for key, value in self.__dict__.iteritems()]
27196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27197 
 
27198 
  def __eq__(self, other):
27199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27200 
 
27201 
  def __ne__(self, other):
27202 
    return not (self == other)
27203 
 
27204 
class getRechargeOrders_args:
27205 
  """
27206 
  Attributes:
27207 
   - userId
27208 
  """
27209 
 
27210 
  thrift_spec = (
27211 
    None, # 0
27212 
    (1, TType.I64, 'userId', None, None, ), # 1
27213 
  )
27214 
 
27215 
  def __init__(self, userId=None,):
27216 
    self.userId = userId
27217 
 
27218 
  def read(self, iprot):
27219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27221 
      return
27222 
    iprot.readStructBegin()
27223 
    while True:
27224 
      (fname, ftype, fid) = iprot.readFieldBegin()
27225 
      if ftype == TType.STOP:
27226 
        break
27227 
      if fid == 1:
27228 
        if ftype == TType.I64:
27229 
          self.userId = iprot.readI64();
27230 
        else:
27231 
          iprot.skip(ftype)
27232 
      else:
27233 
        iprot.skip(ftype)
27234 
      iprot.readFieldEnd()
27235 
    iprot.readStructEnd()
27236 
 
27237 
  def write(self, oprot):
27238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27240 
      return
27241 
    oprot.writeStructBegin('getRechargeOrders_args')
27242 
    if self.userId is not None:
27243 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27244 
      oprot.writeI64(self.userId)
27245 
      oprot.writeFieldEnd()
27246 
    oprot.writeFieldStop()
27247 
    oprot.writeStructEnd()
27248 
 
27249 
  def validate(self):
27250 
    return
27251 
 
27252 
 
27253 
  def __repr__(self):
27254 
    L = ['%s=%r' % (key, value)
27255 
      for key, value in self.__dict__.iteritems()]
27256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27257 
 
27258 
  def __eq__(self, other):
27259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27260 
 
27261 
  def __ne__(self, other):
27262 
    return not (self == other)
27263 
 
27264 
class getRechargeOrders_result:
27265 
  """
27266 
  Attributes:
27267 
   - success
27268 
  """
27269 
 
27270 
  thrift_spec = (
27271 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27272 
  )
27273 
 
27274 
  def __init__(self, success=None,):
27275 
    self.success = success
27276 
 
27277 
  def read(self, iprot):
27278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27280 
      return
27281 
    iprot.readStructBegin()
27282 
    while True:
27283 
      (fname, ftype, fid) = iprot.readFieldBegin()
27284 
      if ftype == TType.STOP:
27285 
        break
27286 
      if fid == 0:
27287 
        if ftype == TType.LIST:
27288 
          self.success = []
6188 rajveer 27289 
          (_etype659, _size656) = iprot.readListBegin()
27290 
          for _i660 in xrange(_size656):
27291 
            _elem661 = RechargeOrder()
27292 
            _elem661.read(iprot)
27293 
            self.success.append(_elem661)
6031 rajveer 27294 
          iprot.readListEnd()
27295 
        else:
27296 
          iprot.skip(ftype)
27297 
      else:
27298 
        iprot.skip(ftype)
27299 
      iprot.readFieldEnd()
27300 
    iprot.readStructEnd()
27301 
 
27302 
  def write(self, oprot):
27303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27305 
      return
27306 
    oprot.writeStructBegin('getRechargeOrders_result')
27307 
    if self.success is not None:
27308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27310 
      for iter662 in self.success:
27311 
        iter662.write(oprot)
6031 rajveer 27312 
      oprot.writeListEnd()
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 
 
6000 mandeep.dh 27332 
class updateRechargeOrderStatus_args:
27333 
  """
27334 
  Attributes:
27335 
   - rechargeOrderId
27336 
   - rechargeOrderStatus
27337 
  """
27338 
 
27339 
  thrift_spec = (
27340 
    None, # 0
27341 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27342 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27343 
  )
27344 
 
27345 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27346 
    self.rechargeOrderId = rechargeOrderId
27347 
    self.rechargeOrderStatus = rechargeOrderStatus
27348 
 
27349 
  def read(self, iprot):
27350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27352 
      return
27353 
    iprot.readStructBegin()
27354 
    while True:
27355 
      (fname, ftype, fid) = iprot.readFieldBegin()
27356 
      if ftype == TType.STOP:
27357 
        break
27358 
      if fid == 1:
27359 
        if ftype == TType.I64:
27360 
          self.rechargeOrderId = iprot.readI64();
27361 
        else:
27362 
          iprot.skip(ftype)
27363 
      elif fid == 2:
27364 
        if ftype == TType.I32:
27365 
          self.rechargeOrderStatus = iprot.readI32();
27366 
        else:
27367 
          iprot.skip(ftype)
27368 
      else:
27369 
        iprot.skip(ftype)
27370 
      iprot.readFieldEnd()
27371 
    iprot.readStructEnd()
27372 
 
27373 
  def write(self, oprot):
27374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27376 
      return
27377 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27378 
    if self.rechargeOrderId is not None:
27379 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27380 
      oprot.writeI64(self.rechargeOrderId)
27381 
      oprot.writeFieldEnd()
27382 
    if self.rechargeOrderStatus is not None:
27383 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27384 
      oprot.writeI32(self.rechargeOrderStatus)
27385 
      oprot.writeFieldEnd()
27386 
    oprot.writeFieldStop()
27387 
    oprot.writeStructEnd()
27388 
 
27389 
  def validate(self):
27390 
    return
27391 
 
27392 
 
27393 
  def __repr__(self):
27394 
    L = ['%s=%r' % (key, value)
27395 
      for key, value in self.__dict__.iteritems()]
27396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27397 
 
27398 
  def __eq__(self, other):
27399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27400 
 
27401 
  def __ne__(self, other):
27402 
    return not (self == other)
27403 
 
27404 
class updateRechargeOrderStatus_result:
27405 
  """
27406 
  Attributes:
6031 rajveer 27407 
   - success
6000 mandeep.dh 27408 
   - ex
27409 
  """
27410 
 
27411 
  thrift_spec = (
6031 rajveer 27412 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27414 
  )
27415 
 
6031 rajveer 27416 
  def __init__(self, success=None, ex=None,):
27417 
    self.success = success
6000 mandeep.dh 27418 
    self.ex = ex
27419 
 
27420 
  def read(self, iprot):
27421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27423 
      return
27424 
    iprot.readStructBegin()
27425 
    while True:
27426 
      (fname, ftype, fid) = iprot.readFieldBegin()
27427 
      if ftype == TType.STOP:
27428 
        break
6031 rajveer 27429 
      if fid == 0:
27430 
        if ftype == TType.BOOL:
27431 
          self.success = iprot.readBool();
27432 
        else:
27433 
          iprot.skip(ftype)
27434 
      elif fid == 1:
6000 mandeep.dh 27435 
        if ftype == TType.STRUCT:
27436 
          self.ex = TransactionServiceException()
27437 
          self.ex.read(iprot)
27438 
        else:
27439 
          iprot.skip(ftype)
27440 
      else:
27441 
        iprot.skip(ftype)
27442 
      iprot.readFieldEnd()
27443 
    iprot.readStructEnd()
27444 
 
27445 
  def write(self, oprot):
27446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27448 
      return
27449 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27450 
    if self.success is not None:
27451 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27452 
      oprot.writeBool(self.success)
27453 
      oprot.writeFieldEnd()
6000 mandeep.dh 27454 
    if self.ex is not None:
27455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27456 
      self.ex.write(oprot)
27457 
      oprot.writeFieldEnd()
27458 
    oprot.writeFieldStop()
27459 
    oprot.writeStructEnd()
27460 
 
27461 
  def validate(self):
27462 
    return
27463 
 
27464 
 
27465 
  def __repr__(self):
27466 
    L = ['%s=%r' % (key, value)
27467 
      for key, value in self.__dict__.iteritems()]
27468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27469 
 
27470 
  def __eq__(self, other):
27471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27472 
 
27473 
  def __ne__(self, other):
27474 
    return not (self == other)
27475 
 
27476 
class activateRechargeTxn_args:
27477 
  """
27478 
  Attributes:
6031 rajveer 27479 
   - rechargeOrderId
6000 mandeep.dh 27480 
  """
27481 
 
27482 
  thrift_spec = (
27483 
    None, # 0
6031 rajveer 27484 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27485 
  )
27486 
 
6031 rajveer 27487 
  def __init__(self, rechargeOrderId=None,):
27488 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27489 
 
27490 
  def read(self, iprot):
27491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27493 
      return
27494 
    iprot.readStructBegin()
27495 
    while True:
27496 
      (fname, ftype, fid) = iprot.readFieldBegin()
27497 
      if ftype == TType.STOP:
27498 
        break
27499 
      if fid == 1:
6031 rajveer 27500 
        if ftype == TType.I64:
27501 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27502 
        else:
27503 
          iprot.skip(ftype)
27504 
      else:
27505 
        iprot.skip(ftype)
27506 
      iprot.readFieldEnd()
27507 
    iprot.readStructEnd()
27508 
 
27509 
  def write(self, oprot):
27510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27512 
      return
27513 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27514 
    if self.rechargeOrderId is not None:
27515 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27516 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27517 
      oprot.writeFieldEnd()
27518 
    oprot.writeFieldStop()
27519 
    oprot.writeStructEnd()
27520 
 
27521 
  def validate(self):
27522 
    return
27523 
 
27524 
 
27525 
  def __repr__(self):
27526 
    L = ['%s=%r' % (key, value)
27527 
      for key, value in self.__dict__.iteritems()]
27528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27529 
 
27530 
  def __eq__(self, other):
27531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27532 
 
27533 
  def __ne__(self, other):
27534 
    return not (self == other)
27535 
 
27536 
class activateRechargeTxn_result:
27537 
  """
27538 
  Attributes:
27539 
   - success
27540 
   - ex
27541 
  """
27542 
 
27543 
  thrift_spec = (
6031 rajveer 27544 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27546 
  )
27547 
 
27548 
  def __init__(self, success=None, ex=None,):
27549 
    self.success = success
27550 
    self.ex = ex
27551 
 
27552 
  def read(self, iprot):
27553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27555 
      return
27556 
    iprot.readStructBegin()
27557 
    while True:
27558 
      (fname, ftype, fid) = iprot.readFieldBegin()
27559 
      if ftype == TType.STOP:
27560 
        break
27561 
      if fid == 0:
6031 rajveer 27562 
        if ftype == TType.BOOL:
27563 
          self.success = iprot.readBool();
6000 mandeep.dh 27564 
        else:
27565 
          iprot.skip(ftype)
27566 
      elif fid == 1:
27567 
        if ftype == TType.STRUCT:
27568 
          self.ex = TransactionServiceException()
27569 
          self.ex.read(iprot)
27570 
        else:
27571 
          iprot.skip(ftype)
27572 
      else:
27573 
        iprot.skip(ftype)
27574 
      iprot.readFieldEnd()
27575 
    iprot.readStructEnd()
27576 
 
27577 
  def write(self, oprot):
27578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27580 
      return
27581 
    oprot.writeStructBegin('activateRechargeTxn_result')
27582 
    if self.success is not None:
6031 rajveer 27583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27584 
      oprot.writeBool(self.success)
6000 mandeep.dh 27585 
      oprot.writeFieldEnd()
27586 
    if self.ex is not None:
27587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27588 
      self.ex.write(oprot)
27589 
      oprot.writeFieldEnd()
27590 
    oprot.writeFieldStop()
27591 
    oprot.writeStructEnd()
27592 
 
27593 
  def validate(self):
27594 
    return
27595 
 
27596 
 
27597 
  def __repr__(self):
27598 
    L = ['%s=%r' % (key, value)
27599 
      for key, value in self.__dict__.iteritems()]
27600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27601 
 
27602 
  def __eq__(self, other):
27603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27604 
 
27605 
  def __ne__(self, other):
27606 
    return not (self == other)
27607 
 
6031 rajveer 27608 
class getUserWallet_args:
6000 mandeep.dh 27609 
  """
27610 
  Attributes:
6031 rajveer 27611 
   - userId
6000 mandeep.dh 27612 
  """
27613 
 
27614 
  thrift_spec = (
27615 
    None, # 0
6031 rajveer 27616 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27617 
  )
27618 
 
6031 rajveer 27619 
  def __init__(self, userId=None,):
27620 
    self.userId = userId
6000 mandeep.dh 27621 
 
27622 
  def read(self, iprot):
27623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27625 
      return
27626 
    iprot.readStructBegin()
27627 
    while True:
27628 
      (fname, ftype, fid) = iprot.readFieldBegin()
27629 
      if ftype == TType.STOP:
27630 
        break
27631 
      if fid == 1:
27632 
        if ftype == TType.I64:
6031 rajveer 27633 
          self.userId = iprot.readI64();
6000 mandeep.dh 27634 
        else:
27635 
          iprot.skip(ftype)
27636 
      else:
27637 
        iprot.skip(ftype)
27638 
      iprot.readFieldEnd()
27639 
    iprot.readStructEnd()
27640 
 
27641 
  def write(self, oprot):
27642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27644 
      return
6031 rajveer 27645 
    oprot.writeStructBegin('getUserWallet_args')
27646 
    if self.userId is not None:
27647 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27648 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27649 
      oprot.writeFieldEnd()
27650 
    oprot.writeFieldStop()
27651 
    oprot.writeStructEnd()
27652 
 
27653 
  def validate(self):
27654 
    return
27655 
 
27656 
 
27657 
  def __repr__(self):
27658 
    L = ['%s=%r' % (key, value)
27659 
      for key, value in self.__dict__.iteritems()]
27660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27661 
 
27662 
  def __eq__(self, other):
27663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27664 
 
27665 
  def __ne__(self, other):
27666 
    return not (self == other)
27667 
 
6031 rajveer 27668 
class getUserWallet_result:
6000 mandeep.dh 27669 
  """
27670 
  Attributes:
27671 
   - success
27672 
  """
27673 
 
27674 
  thrift_spec = (
6031 rajveer 27675 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27676 
  )
27677 
 
27678 
  def __init__(self, success=None,):
27679 
    self.success = success
27680 
 
27681 
  def read(self, iprot):
27682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27684 
      return
27685 
    iprot.readStructBegin()
27686 
    while True:
27687 
      (fname, ftype, fid) = iprot.readFieldBegin()
27688 
      if ftype == TType.STOP:
27689 
        break
27690 
      if fid == 0:
6031 rajveer 27691 
        if ftype == TType.STRUCT:
27692 
          self.success = UserWallet()
27693 
          self.success.read(iprot)
6000 mandeep.dh 27694 
        else:
27695 
          iprot.skip(ftype)
27696 
      else:
27697 
        iprot.skip(ftype)
27698 
      iprot.readFieldEnd()
27699 
    iprot.readStructEnd()
27700 
 
27701 
  def write(self, oprot):
27702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27704 
      return
6031 rajveer 27705 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27706 
    if self.success is not None:
6031 rajveer 27707 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27708 
      self.success.write(oprot)
6000 mandeep.dh 27709 
      oprot.writeFieldEnd()
27710 
    oprot.writeFieldStop()
27711 
    oprot.writeStructEnd()
27712 
 
27713 
  def validate(self):
27714 
    return
27715 
 
27716 
 
27717 
  def __repr__(self):
27718 
    L = ['%s=%r' % (key, value)
27719 
      for key, value in self.__dict__.iteritems()]
27720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27721 
 
27722 
  def __eq__(self, other):
27723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27724 
 
27725 
  def __ne__(self, other):
27726 
    return not (self == other)
27727 
 
6031 rajveer 27728 
class getUserWalletHistory_args:
6000 mandeep.dh 27729 
  """
27730 
  Attributes:
6031 rajveer 27731 
   - userId
6000 mandeep.dh 27732 
  """
27733 
 
27734 
  thrift_spec = (
27735 
    None, # 0
6031 rajveer 27736 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27737 
  )
27738 
 
6031 rajveer 27739 
  def __init__(self, userId=None,):
27740 
    self.userId = userId
6000 mandeep.dh 27741 
 
27742 
  def read(self, iprot):
27743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27745 
      return
27746 
    iprot.readStructBegin()
27747 
    while True:
27748 
      (fname, ftype, fid) = iprot.readFieldBegin()
27749 
      if ftype == TType.STOP:
27750 
        break
27751 
      if fid == 1:
27752 
        if ftype == TType.I64:
6031 rajveer 27753 
          self.userId = iprot.readI64();
6000 mandeep.dh 27754 
        else:
27755 
          iprot.skip(ftype)
27756 
      else:
27757 
        iprot.skip(ftype)
27758 
      iprot.readFieldEnd()
27759 
    iprot.readStructEnd()
27760 
 
27761 
  def write(self, oprot):
27762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27764 
      return
6031 rajveer 27765 
    oprot.writeStructBegin('getUserWalletHistory_args')
27766 
    if self.userId is not None:
27767 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27768 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27769 
      oprot.writeFieldEnd()
27770 
    oprot.writeFieldStop()
27771 
    oprot.writeStructEnd()
27772 
 
27773 
  def validate(self):
27774 
    return
27775 
 
27776 
 
27777 
  def __repr__(self):
27778 
    L = ['%s=%r' % (key, value)
27779 
      for key, value in self.__dict__.iteritems()]
27780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27781 
 
27782 
  def __eq__(self, other):
27783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27784 
 
27785 
  def __ne__(self, other):
27786 
    return not (self == other)
27787 
 
6031 rajveer 27788 
class getUserWalletHistory_result:
6000 mandeep.dh 27789 
  """
27790 
  Attributes:
27791 
   - success
27792 
  """
27793 
 
27794 
  thrift_spec = (
6031 rajveer 27795 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27796 
  )
27797 
 
27798 
  def __init__(self, success=None,):
27799 
    self.success = success
27800 
 
27801 
  def read(self, iprot):
27802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27804 
      return
27805 
    iprot.readStructBegin()
27806 
    while True:
27807 
      (fname, ftype, fid) = iprot.readFieldBegin()
27808 
      if ftype == TType.STOP:
27809 
        break
27810 
      if fid == 0:
27811 
        if ftype == TType.LIST:
27812 
          self.success = []
6188 rajveer 27813 
          (_etype666, _size663) = iprot.readListBegin()
27814 
          for _i667 in xrange(_size663):
27815 
            _elem668 = UserWalletHistory()
27816 
            _elem668.read(iprot)
27817 
            self.success.append(_elem668)
6000 mandeep.dh 27818 
          iprot.readListEnd()
27819 
        else:
27820 
          iprot.skip(ftype)
27821 
      else:
27822 
        iprot.skip(ftype)
27823 
      iprot.readFieldEnd()
27824 
    iprot.readStructEnd()
27825 
 
27826 
  def write(self, oprot):
27827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27829 
      return
6031 rajveer 27830 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27831 
    if self.success is not None:
27832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27834 
      for iter669 in self.success:
27835 
        iter669.write(oprot)
6000 mandeep.dh 27836 
      oprot.writeListEnd()
27837 
      oprot.writeFieldEnd()
27838 
    oprot.writeFieldStop()
27839 
    oprot.writeStructEnd()
27840 
 
27841 
  def validate(self):
27842 
    return
27843 
 
27844 
 
27845 
  def __repr__(self):
27846 
    L = ['%s=%r' % (key, value)
27847 
      for key, value in self.__dict__.iteritems()]
27848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27849 
 
27850 
  def __eq__(self, other):
27851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27852 
 
27853 
  def __ne__(self, other):
27854 
    return not (self == other)
6048 rajveer 27855 
 
6050 anupam.sin 27856 
class getRechargeOrdersForTransaction_args:
27857 
  """
27858 
  Attributes:
27859 
   - txnId
27860 
  """
27861 
 
27862 
  thrift_spec = (
27863 
    None, # 0
27864 
    (1, TType.I64, 'txnId', None, None, ), # 1
27865 
  )
27866 
 
27867 
  def __init__(self, txnId=None,):
27868 
    self.txnId = txnId
27869 
 
27870 
  def read(self, iprot):
27871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27873 
      return
27874 
    iprot.readStructBegin()
27875 
    while True:
27876 
      (fname, ftype, fid) = iprot.readFieldBegin()
27877 
      if ftype == TType.STOP:
27878 
        break
27879 
      if fid == 1:
27880 
        if ftype == TType.I64:
27881 
          self.txnId = iprot.readI64();
27882 
        else:
27883 
          iprot.skip(ftype)
27884 
      else:
27885 
        iprot.skip(ftype)
27886 
      iprot.readFieldEnd()
27887 
    iprot.readStructEnd()
27888 
 
27889 
  def write(self, oprot):
27890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27892 
      return
27893 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27894 
    if self.txnId is not None:
27895 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27896 
      oprot.writeI64(self.txnId)
27897 
      oprot.writeFieldEnd()
27898 
    oprot.writeFieldStop()
27899 
    oprot.writeStructEnd()
27900 
 
27901 
  def validate(self):
27902 
    return
27903 
 
27904 
 
27905 
  def __repr__(self):
27906 
    L = ['%s=%r' % (key, value)
27907 
      for key, value in self.__dict__.iteritems()]
27908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27909 
 
27910 
  def __eq__(self, other):
27911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27912 
 
27913 
  def __ne__(self, other):
27914 
    return not (self == other)
27915 
 
27916 
class getRechargeOrdersForTransaction_result:
27917 
  """
27918 
  Attributes:
27919 
   - success
27920 
   - ex
27921 
  """
27922 
 
27923 
  thrift_spec = (
27924 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27926 
  )
27927 
 
27928 
  def __init__(self, success=None, ex=None,):
27929 
    self.success = success
27930 
    self.ex = ex
27931 
 
27932 
  def read(self, iprot):
27933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27935 
      return
27936 
    iprot.readStructBegin()
27937 
    while True:
27938 
      (fname, ftype, fid) = iprot.readFieldBegin()
27939 
      if ftype == TType.STOP:
27940 
        break
27941 
      if fid == 0:
27942 
        if ftype == TType.STRUCT:
27943 
          self.success = RechargeOrder()
27944 
          self.success.read(iprot)
27945 
        else:
27946 
          iprot.skip(ftype)
27947 
      elif fid == 1:
27948 
        if ftype == TType.STRUCT:
27949 
          self.ex = TransactionServiceException()
27950 
          self.ex.read(iprot)
27951 
        else:
27952 
          iprot.skip(ftype)
27953 
      else:
27954 
        iprot.skip(ftype)
27955 
      iprot.readFieldEnd()
27956 
    iprot.readStructEnd()
27957 
 
27958 
  def write(self, oprot):
27959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27961 
      return
27962 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27963 
    if self.success is not None:
27964 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27965 
      self.success.write(oprot)
27966 
      oprot.writeFieldEnd()
27967 
    if self.ex is not None:
27968 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27969 
      self.ex.write(oprot)
27970 
      oprot.writeFieldEnd()
27971 
    oprot.writeFieldStop()
27972 
    oprot.writeStructEnd()
27973 
 
27974 
  def validate(self):
27975 
    return
27976 
 
27977 
 
27978 
  def __repr__(self):
27979 
    L = ['%s=%r' % (key, value)
27980 
      for key, value in self.__dict__.iteritems()]
27981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27982 
 
27983 
  def __eq__(self, other):
27984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27985 
 
27986 
  def __ne__(self, other):
27987 
    return not (self == other)
27988 
 
6048 rajveer 27989 
class getServiceProviders_args:
27990 
  """
27991 
  Attributes:
27992 
   - rechargeType
6206 rajveer 27993 
   - onlyActive
6048 rajveer 27994 
  """
27995 
 
27996 
  thrift_spec = (
27997 
    None, # 0
27998 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27999 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28000 
  )
28001 
 
6206 rajveer 28002 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28003 
    self.rechargeType = rechargeType
6206 rajveer 28004 
    self.onlyActive = onlyActive
6048 rajveer 28005 
 
28006 
  def read(self, iprot):
28007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28009 
      return
28010 
    iprot.readStructBegin()
28011 
    while True:
28012 
      (fname, ftype, fid) = iprot.readFieldBegin()
28013 
      if ftype == TType.STOP:
28014 
        break
28015 
      if fid == 1:
28016 
        if ftype == TType.I32:
28017 
          self.rechargeType = iprot.readI32();
28018 
        else:
28019 
          iprot.skip(ftype)
6206 rajveer 28020 
      elif fid == 2:
28021 
        if ftype == TType.BOOL:
28022 
          self.onlyActive = iprot.readBool();
28023 
        else:
28024 
          iprot.skip(ftype)
6048 rajveer 28025 
      else:
28026 
        iprot.skip(ftype)
28027 
      iprot.readFieldEnd()
28028 
    iprot.readStructEnd()
28029 
 
28030 
  def write(self, oprot):
28031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28033 
      return
28034 
    oprot.writeStructBegin('getServiceProviders_args')
28035 
    if self.rechargeType is not None:
28036 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28037 
      oprot.writeI32(self.rechargeType)
28038 
      oprot.writeFieldEnd()
6206 rajveer 28039 
    if self.onlyActive is not None:
28040 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28041 
      oprot.writeBool(self.onlyActive)
28042 
      oprot.writeFieldEnd()
6048 rajveer 28043 
    oprot.writeFieldStop()
28044 
    oprot.writeStructEnd()
28045 
 
28046 
  def validate(self):
28047 
    return
28048 
 
28049 
 
28050 
  def __repr__(self):
28051 
    L = ['%s=%r' % (key, value)
28052 
      for key, value in self.__dict__.iteritems()]
28053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28054 
 
28055 
  def __eq__(self, other):
28056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28057 
 
28058 
  def __ne__(self, other):
28059 
    return not (self == other)
28060 
 
28061 
class getServiceProviders_result:
28062 
  """
28063 
  Attributes:
28064 
   - success
28065 
  """
28066 
 
28067 
  thrift_spec = (
28068 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28069 
  )
28070 
 
28071 
  def __init__(self, success=None,):
28072 
    self.success = success
28073 
 
28074 
  def read(self, iprot):
28075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28077 
      return
28078 
    iprot.readStructBegin()
28079 
    while True:
28080 
      (fname, ftype, fid) = iprot.readFieldBegin()
28081 
      if ftype == TType.STOP:
28082 
        break
28083 
      if fid == 0:
28084 
        if ftype == TType.MAP:
28085 
          self.success = {}
6188 rajveer 28086 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28087 
          for _i674 in xrange(_size670):
28088 
            _key675 = iprot.readI64();
28089 
            _val676 = iprot.readString();
28090 
            self.success[_key675] = _val676
6048 rajveer 28091 
          iprot.readMapEnd()
28092 
        else:
28093 
          iprot.skip(ftype)
28094 
      else:
28095 
        iprot.skip(ftype)
28096 
      iprot.readFieldEnd()
28097 
    iprot.readStructEnd()
28098 
 
28099 
  def write(self, oprot):
28100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28102 
      return
28103 
    oprot.writeStructBegin('getServiceProviders_result')
28104 
    if self.success is not None:
28105 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28106 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28107 
      for kiter677,viter678 in self.success.items():
28108 
        oprot.writeI64(kiter677)
28109 
        oprot.writeString(viter678)
6048 rajveer 28110 
      oprot.writeMapEnd()
28111 
      oprot.writeFieldEnd()
28112 
    oprot.writeFieldStop()
28113 
    oprot.writeStructEnd()
28114 
 
28115 
  def validate(self):
28116 
    return
28117 
 
28118 
 
28119 
  def __repr__(self):
28120 
    L = ['%s=%r' % (key, value)
28121 
      for key, value in self.__dict__.iteritems()]
28122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28123 
 
28124 
  def __eq__(self, other):
28125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28126 
 
28127 
  def __ne__(self, other):
28128 
    return not (self == other)
28129 
 
28130 
class getServiceProviderForDevice_args:
28131 
  """
28132 
  Attributes:
6049 rajveer 28133 
   - rechargeType
6048 rajveer 28134 
   - deviceNumber
28135 
  """
28136 
 
28137 
  thrift_spec = (
28138 
    None, # 0
6049 rajveer 28139 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28140 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28141 
  )
28142 
 
6049 rajveer 28143 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28144 
    self.rechargeType = rechargeType
6048 rajveer 28145 
    self.deviceNumber = deviceNumber
28146 
 
28147 
  def read(self, iprot):
28148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28150 
      return
28151 
    iprot.readStructBegin()
28152 
    while True:
28153 
      (fname, ftype, fid) = iprot.readFieldBegin()
28154 
      if ftype == TType.STOP:
28155 
        break
28156 
      if fid == 1:
6049 rajveer 28157 
        if ftype == TType.I32:
28158 
          self.rechargeType = iprot.readI32();
28159 
        else:
28160 
          iprot.skip(ftype)
28161 
      elif fid == 2:
6048 rajveer 28162 
        if ftype == TType.STRING:
28163 
          self.deviceNumber = iprot.readString();
28164 
        else:
28165 
          iprot.skip(ftype)
28166 
      else:
28167 
        iprot.skip(ftype)
28168 
      iprot.readFieldEnd()
28169 
    iprot.readStructEnd()
28170 
 
28171 
  def write(self, oprot):
28172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28174 
      return
28175 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28176 
    if self.rechargeType is not None:
28177 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28178 
      oprot.writeI32(self.rechargeType)
28179 
      oprot.writeFieldEnd()
6048 rajveer 28180 
    if self.deviceNumber is not None:
6049 rajveer 28181 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28182 
      oprot.writeString(self.deviceNumber)
28183 
      oprot.writeFieldEnd()
28184 
    oprot.writeFieldStop()
28185 
    oprot.writeStructEnd()
28186 
 
28187 
  def validate(self):
28188 
    return
28189 
 
28190 
 
28191 
  def __repr__(self):
28192 
    L = ['%s=%r' % (key, value)
28193 
      for key, value in self.__dict__.iteritems()]
28194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28195 
 
28196 
  def __eq__(self, other):
28197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28198 
 
28199 
  def __ne__(self, other):
28200 
    return not (self == other)
28201 
 
28202 
class getServiceProviderForDevice_result:
28203 
  """
28204 
  Attributes:
28205 
   - success
28206 
  """
28207 
 
28208 
  thrift_spec = (
6289 anupam.sin 28209 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28210 
  )
28211 
 
28212 
  def __init__(self, success=None,):
28213 
    self.success = success
28214 
 
28215 
  def read(self, iprot):
28216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28218 
      return
28219 
    iprot.readStructBegin()
28220 
    while True:
28221 
      (fname, ftype, fid) = iprot.readFieldBegin()
28222 
      if ftype == TType.STOP:
28223 
        break
28224 
      if fid == 0:
6289 anupam.sin 28225 
        if ftype == TType.STRUCT:
28226 
          self.success = DeviceNumberInfo()
28227 
          self.success.read(iprot)
6048 rajveer 28228 
        else:
28229 
          iprot.skip(ftype)
28230 
      else:
28231 
        iprot.skip(ftype)
28232 
      iprot.readFieldEnd()
28233 
    iprot.readStructEnd()
28234 
 
28235 
  def write(self, oprot):
28236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28238 
      return
28239 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28240 
    if self.success is not None:
6289 anupam.sin 28241 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28242 
      self.success.write(oprot)
6048 rajveer 28243 
      oprot.writeFieldEnd()
28244 
    oprot.writeFieldStop()
28245 
    oprot.writeStructEnd()
28246 
 
28247 
  def validate(self):
28248 
    return
28249 
 
28250 
 
28251 
  def __repr__(self):
28252 
    L = ['%s=%r' % (key, value)
28253 
      for key, value in self.__dict__.iteritems()]
28254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28255 
 
28256 
  def __eq__(self, other):
28257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28258 
 
28259 
  def __ne__(self, other):
28260 
    return not (self == other)
6094 rajveer 28261 
 
6269 rajveer 28262 
class validateRecharge_args:
28263 
  """
28264 
  Attributes:
28265 
   - rechargeType
28266 
   - deviceNumber
6307 anupam.sin 28267 
   - userSelectedProviderId
6591 anupam.sin 28268 
   - clientAddress
6269 rajveer 28269 
  """
28270 
 
28271 
  thrift_spec = (
28272 
    None, # 0
28273 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28274 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28275 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28276 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28277 
  )
28278 
 
6591 anupam.sin 28279 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28280 
    self.rechargeType = rechargeType
28281 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28282 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28283 
    self.clientAddress = clientAddress
6269 rajveer 28284 
 
28285 
  def read(self, iprot):
28286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28288 
      return
28289 
    iprot.readStructBegin()
28290 
    while True:
28291 
      (fname, ftype, fid) = iprot.readFieldBegin()
28292 
      if ftype == TType.STOP:
28293 
        break
28294 
      if fid == 1:
28295 
        if ftype == TType.I32:
28296 
          self.rechargeType = iprot.readI32();
28297 
        else:
28298 
          iprot.skip(ftype)
28299 
      elif fid == 2:
28300 
        if ftype == TType.STRING:
28301 
          self.deviceNumber = iprot.readString();
28302 
        else:
28303 
          iprot.skip(ftype)
6307 anupam.sin 28304 
      elif fid == 3:
28305 
        if ftype == TType.I64:
28306 
          self.userSelectedProviderId = iprot.readI64();
28307 
        else:
28308 
          iprot.skip(ftype)
6591 anupam.sin 28309 
      elif fid == 4:
28310 
        if ftype == TType.STRING:
28311 
          self.clientAddress = iprot.readString();
28312 
        else:
28313 
          iprot.skip(ftype)
6269 rajveer 28314 
      else:
28315 
        iprot.skip(ftype)
28316 
      iprot.readFieldEnd()
28317 
    iprot.readStructEnd()
28318 
 
28319 
  def write(self, oprot):
28320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28322 
      return
28323 
    oprot.writeStructBegin('validateRecharge_args')
28324 
    if self.rechargeType is not None:
28325 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28326 
      oprot.writeI32(self.rechargeType)
28327 
      oprot.writeFieldEnd()
28328 
    if self.deviceNumber is not None:
28329 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28330 
      oprot.writeString(self.deviceNumber)
28331 
      oprot.writeFieldEnd()
6307 anupam.sin 28332 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28333 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28334 
      oprot.writeI64(self.userSelectedProviderId)
28335 
      oprot.writeFieldEnd()
6591 anupam.sin 28336 
    if self.clientAddress is not None:
28337 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28338 
      oprot.writeString(self.clientAddress)
28339 
      oprot.writeFieldEnd()
6269 rajveer 28340 
    oprot.writeFieldStop()
28341 
    oprot.writeStructEnd()
28342 
 
28343 
  def validate(self):
28344 
    return
28345 
 
28346 
 
28347 
  def __repr__(self):
28348 
    L = ['%s=%r' % (key, value)
28349 
      for key, value in self.__dict__.iteritems()]
28350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28351 
 
28352 
  def __eq__(self, other):
28353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28354 
 
28355 
  def __ne__(self, other):
28356 
    return not (self == other)
28357 
 
28358 
class validateRecharge_result:
28359 
  """
28360 
  Attributes:
28361 
   - success
28362 
  """
28363 
 
28364 
  thrift_spec = (
28365 
    (0, TType.STRING, 'success', None, None, ), # 0
28366 
  )
28367 
 
28368 
  def __init__(self, success=None,):
28369 
    self.success = success
28370 
 
28371 
  def read(self, iprot):
28372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28374 
      return
28375 
    iprot.readStructBegin()
28376 
    while True:
28377 
      (fname, ftype, fid) = iprot.readFieldBegin()
28378 
      if ftype == TType.STOP:
28379 
        break
28380 
      if fid == 0:
28381 
        if ftype == TType.STRING:
28382 
          self.success = iprot.readString();
28383 
        else:
28384 
          iprot.skip(ftype)
28385 
      else:
28386 
        iprot.skip(ftype)
28387 
      iprot.readFieldEnd()
28388 
    iprot.readStructEnd()
28389 
 
28390 
  def write(self, oprot):
28391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28393 
      return
28394 
    oprot.writeStructBegin('validateRecharge_result')
28395 
    if self.success is not None:
28396 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28397 
      oprot.writeString(self.success)
28398 
      oprot.writeFieldEnd()
28399 
    oprot.writeFieldStop()
28400 
    oprot.writeStructEnd()
28401 
 
28402 
  def validate(self):
28403 
    return
28404 
 
28405 
 
28406 
  def __repr__(self):
28407 
    L = ['%s=%r' % (key, value)
28408 
      for key, value in self.__dict__.iteritems()]
28409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28410 
 
28411 
  def __eq__(self, other):
28412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28413 
 
28414 
  def __ne__(self, other):
28415 
    return not (self == other)
28416 
 
6094 rajveer 28417 
class getRechargeOrdersForDevice_args:
28418 
  """
28419 
  Attributes:
28420 
   - deviceNumber
28421 
  """
28422 
 
28423 
  thrift_spec = (
28424 
    None, # 0
28425 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28426 
  )
28427 
 
28428 
  def __init__(self, deviceNumber=None,):
28429 
    self.deviceNumber = deviceNumber
28430 
 
28431 
  def read(self, iprot):
28432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28434 
      return
28435 
    iprot.readStructBegin()
28436 
    while True:
28437 
      (fname, ftype, fid) = iprot.readFieldBegin()
28438 
      if ftype == TType.STOP:
28439 
        break
28440 
      if fid == 1:
28441 
        if ftype == TType.STRING:
28442 
          self.deviceNumber = iprot.readString();
28443 
        else:
28444 
          iprot.skip(ftype)
28445 
      else:
28446 
        iprot.skip(ftype)
28447 
      iprot.readFieldEnd()
28448 
    iprot.readStructEnd()
28449 
 
28450 
  def write(self, oprot):
28451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28453 
      return
28454 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28455 
    if self.deviceNumber is not None:
28456 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28457 
      oprot.writeString(self.deviceNumber)
28458 
      oprot.writeFieldEnd()
28459 
    oprot.writeFieldStop()
28460 
    oprot.writeStructEnd()
28461 
 
28462 
  def validate(self):
28463 
    return
28464 
 
28465 
 
28466 
  def __repr__(self):
28467 
    L = ['%s=%r' % (key, value)
28468 
      for key, value in self.__dict__.iteritems()]
28469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28470 
 
28471 
  def __eq__(self, other):
28472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28473 
 
28474 
  def __ne__(self, other):
28475 
    return not (self == other)
28476 
 
28477 
class getRechargeOrdersForDevice_result:
28478 
  """
28479 
  Attributes:
28480 
   - success
28481 
  """
28482 
 
28483 
  thrift_spec = (
28484 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28485 
  )
28486 
 
28487 
  def __init__(self, success=None,):
28488 
    self.success = success
28489 
 
28490 
  def read(self, iprot):
28491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28493 
      return
28494 
    iprot.readStructBegin()
28495 
    while True:
28496 
      (fname, ftype, fid) = iprot.readFieldBegin()
28497 
      if ftype == TType.STOP:
28498 
        break
28499 
      if fid == 0:
28500 
        if ftype == TType.LIST:
28501 
          self.success = []
6188 rajveer 28502 
          (_etype682, _size679) = iprot.readListBegin()
28503 
          for _i683 in xrange(_size679):
28504 
            _elem684 = RechargeOrder()
28505 
            _elem684.read(iprot)
28506 
            self.success.append(_elem684)
6094 rajveer 28507 
          iprot.readListEnd()
28508 
        else:
28509 
          iprot.skip(ftype)
28510 
      else:
28511 
        iprot.skip(ftype)
28512 
      iprot.readFieldEnd()
28513 
    iprot.readStructEnd()
28514 
 
28515 
  def write(self, oprot):
28516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28518 
      return
28519 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28520 
    if self.success is not None:
28521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28523 
      for iter685 in self.success:
28524 
        iter685.write(oprot)
6094 rajveer 28525 
      oprot.writeListEnd()
28526 
      oprot.writeFieldEnd()
28527 
    oprot.writeFieldStop()
28528 
    oprot.writeStructEnd()
28529 
 
28530 
  def validate(self):
28531 
    return
28532 
 
28533 
 
28534 
  def __repr__(self):
28535 
    L = ['%s=%r' % (key, value)
28536 
      for key, value in self.__dict__.iteritems()]
28537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28538 
 
28539 
  def __eq__(self, other):
28540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28541 
 
28542 
  def __ne__(self, other):
28543 
    return not (self == other)
28544 
 
28545 
class addAmountToWallet_args:
28546 
  """
28547 
  Attributes:
28548 
   - userId
28549 
   - orderId
28550 
   - amount
28551 
  """
28552 
 
28553 
  thrift_spec = (
28554 
    None, # 0
28555 
    (1, TType.I64, 'userId', None, None, ), # 1
28556 
    (2, TType.I64, 'orderId', None, None, ), # 2
28557 
    (3, TType.I64, 'amount', None, None, ), # 3
28558 
  )
28559 
 
28560 
  def __init__(self, userId=None, orderId=None, amount=None,):
28561 
    self.userId = userId
28562 
    self.orderId = orderId
28563 
    self.amount = amount
28564 
 
28565 
  def read(self, iprot):
28566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28568 
      return
28569 
    iprot.readStructBegin()
28570 
    while True:
28571 
      (fname, ftype, fid) = iprot.readFieldBegin()
28572 
      if ftype == TType.STOP:
28573 
        break
28574 
      if fid == 1:
28575 
        if ftype == TType.I64:
28576 
          self.userId = iprot.readI64();
28577 
        else:
28578 
          iprot.skip(ftype)
28579 
      elif fid == 2:
28580 
        if ftype == TType.I64:
28581 
          self.orderId = iprot.readI64();
28582 
        else:
28583 
          iprot.skip(ftype)
28584 
      elif fid == 3:
28585 
        if ftype == TType.I64:
28586 
          self.amount = iprot.readI64();
28587 
        else:
28588 
          iprot.skip(ftype)
28589 
      else:
28590 
        iprot.skip(ftype)
28591 
      iprot.readFieldEnd()
28592 
    iprot.readStructEnd()
28593 
 
28594 
  def write(self, oprot):
28595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28597 
      return
28598 
    oprot.writeStructBegin('addAmountToWallet_args')
28599 
    if self.userId is not None:
28600 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28601 
      oprot.writeI64(self.userId)
28602 
      oprot.writeFieldEnd()
28603 
    if self.orderId is not None:
28604 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28605 
      oprot.writeI64(self.orderId)
28606 
      oprot.writeFieldEnd()
28607 
    if self.amount is not None:
28608 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28609 
      oprot.writeI64(self.amount)
28610 
      oprot.writeFieldEnd()
28611 
    oprot.writeFieldStop()
28612 
    oprot.writeStructEnd()
28613 
 
28614 
  def validate(self):
28615 
    return
28616 
 
28617 
 
28618 
  def __repr__(self):
28619 
    L = ['%s=%r' % (key, value)
28620 
      for key, value in self.__dict__.iteritems()]
28621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28622 
 
28623 
  def __eq__(self, other):
28624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28625 
 
28626 
  def __ne__(self, other):
28627 
    return not (self == other)
28628 
 
28629 
class addAmountToWallet_result:
28630 
 
28631 
  thrift_spec = (
28632 
  )
28633 
 
28634 
  def read(self, iprot):
28635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28637 
      return
28638 
    iprot.readStructBegin()
28639 
    while True:
28640 
      (fname, ftype, fid) = iprot.readFieldBegin()
28641 
      if ftype == TType.STOP:
28642 
        break
28643 
      else:
28644 
        iprot.skip(ftype)
28645 
      iprot.readFieldEnd()
28646 
    iprot.readStructEnd()
28647 
 
28648 
  def write(self, oprot):
28649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28651 
      return
28652 
    oprot.writeStructBegin('addAmountToWallet_result')
28653 
    oprot.writeFieldStop()
28654 
    oprot.writeStructEnd()
28655 
 
28656 
  def validate(self):
28657 
    return
28658 
 
28659 
 
28660 
  def __repr__(self):
28661 
    L = ['%s=%r' % (key, value)
28662 
      for key, value in self.__dict__.iteritems()]
28663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28664 
 
28665 
  def __eq__(self, other):
28666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28667 
 
28668 
  def __ne__(self, other):
28669 
    return not (self == other)
6154 rajveer 28670 
 
6188 rajveer 28671 
class getRechargeStatistics_args:
28672 
 
28673 
  thrift_spec = (
28674 
  )
28675 
 
28676 
  def read(self, iprot):
28677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28679 
      return
28680 
    iprot.readStructBegin()
28681 
    while True:
28682 
      (fname, ftype, fid) = iprot.readFieldBegin()
28683 
      if ftype == TType.STOP:
28684 
        break
28685 
      else:
28686 
        iprot.skip(ftype)
28687 
      iprot.readFieldEnd()
28688 
    iprot.readStructEnd()
28689 
 
28690 
  def write(self, oprot):
28691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28693 
      return
28694 
    oprot.writeStructBegin('getRechargeStatistics_args')
28695 
    oprot.writeFieldStop()
28696 
    oprot.writeStructEnd()
28697 
 
28698 
  def validate(self):
28699 
    return
28700 
 
28701 
 
28702 
  def __repr__(self):
28703 
    L = ['%s=%r' % (key, value)
28704 
      for key, value in self.__dict__.iteritems()]
28705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28706 
 
28707 
  def __eq__(self, other):
28708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28709 
 
28710 
  def __ne__(self, other):
28711 
    return not (self == other)
28712 
 
28713 
class getRechargeStatistics_result:
28714 
  """
28715 
  Attributes:
28716 
   - success
28717 
  """
28718 
 
28719 
  thrift_spec = (
28720 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28721 
  )
28722 
 
28723 
  def __init__(self, success=None,):
28724 
    self.success = success
28725 
 
28726 
  def read(self, iprot):
28727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28729 
      return
28730 
    iprot.readStructBegin()
28731 
    while True:
28732 
      (fname, ftype, fid) = iprot.readFieldBegin()
28733 
      if ftype == TType.STOP:
28734 
        break
28735 
      if fid == 0:
28736 
        if ftype == TType.STRUCT:
28737 
          self.success = RechargeStatistics()
28738 
          self.success.read(iprot)
28739 
        else:
28740 
          iprot.skip(ftype)
28741 
      else:
28742 
        iprot.skip(ftype)
28743 
      iprot.readFieldEnd()
28744 
    iprot.readStructEnd()
28745 
 
28746 
  def write(self, oprot):
28747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28749 
      return
28750 
    oprot.writeStructBegin('getRechargeStatistics_result')
28751 
    if self.success is not None:
28752 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28753 
      self.success.write(oprot)
28754 
      oprot.writeFieldEnd()
28755 
    oprot.writeFieldStop()
28756 
    oprot.writeStructEnd()
28757 
 
28758 
  def validate(self):
28759 
    return
28760 
 
28761 
 
28762 
  def __repr__(self):
28763 
    L = ['%s=%r' % (key, value)
28764 
      for key, value in self.__dict__.iteritems()]
28765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28766 
 
28767 
  def __eq__(self, other):
28768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28769 
 
28770 
  def __ne__(self, other):
28771 
    return not (self == other)
28772 
 
6154 rajveer 28773 
class getRechargeOrdersForStatus_args:
28774 
  """
28775 
  Attributes:
28776 
   - status
28777 
  """
28778 
 
28779 
  thrift_spec = (
28780 
    None, # 0
28781 
    (1, TType.I64, 'status', None, None, ), # 1
28782 
  )
28783 
 
28784 
  def __init__(self, status=None,):
28785 
    self.status = status
28786 
 
28787 
  def read(self, iprot):
28788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28790 
      return
28791 
    iprot.readStructBegin()
28792 
    while True:
28793 
      (fname, ftype, fid) = iprot.readFieldBegin()
28794 
      if ftype == TType.STOP:
28795 
        break
28796 
      if fid == 1:
28797 
        if ftype == TType.I64:
28798 
          self.status = iprot.readI64();
28799 
        else:
28800 
          iprot.skip(ftype)
28801 
      else:
28802 
        iprot.skip(ftype)
28803 
      iprot.readFieldEnd()
28804 
    iprot.readStructEnd()
28805 
 
28806 
  def write(self, oprot):
28807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28809 
      return
28810 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28811 
    if self.status is not None:
28812 
      oprot.writeFieldBegin('status', TType.I64, 1)
28813 
      oprot.writeI64(self.status)
28814 
      oprot.writeFieldEnd()
28815 
    oprot.writeFieldStop()
28816 
    oprot.writeStructEnd()
28817 
 
28818 
  def validate(self):
28819 
    return
28820 
 
28821 
 
28822 
  def __repr__(self):
28823 
    L = ['%s=%r' % (key, value)
28824 
      for key, value in self.__dict__.iteritems()]
28825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28826 
 
28827 
  def __eq__(self, other):
28828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28829 
 
28830 
  def __ne__(self, other):
28831 
    return not (self == other)
28832 
 
28833 
class getRechargeOrdersForStatus_result:
28834 
  """
28835 
  Attributes:
28836 
   - success
28837 
  """
28838 
 
28839 
  thrift_spec = (
28840 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28841 
  )
28842 
 
28843 
  def __init__(self, success=None,):
28844 
    self.success = success
28845 
 
28846 
  def read(self, iprot):
28847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28849 
      return
28850 
    iprot.readStructBegin()
28851 
    while True:
28852 
      (fname, ftype, fid) = iprot.readFieldBegin()
28853 
      if ftype == TType.STOP:
28854 
        break
28855 
      if fid == 0:
28856 
        if ftype == TType.LIST:
28857 
          self.success = []
6188 rajveer 28858 
          (_etype689, _size686) = iprot.readListBegin()
28859 
          for _i690 in xrange(_size686):
28860 
            _elem691 = RechargeOrder()
28861 
            _elem691.read(iprot)
28862 
            self.success.append(_elem691)
6154 rajveer 28863 
          iprot.readListEnd()
28864 
        else:
28865 
          iprot.skip(ftype)
28866 
      else:
28867 
        iprot.skip(ftype)
28868 
      iprot.readFieldEnd()
28869 
    iprot.readStructEnd()
28870 
 
28871 
  def write(self, oprot):
28872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28874 
      return
28875 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28876 
    if self.success is not None:
28877 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28878 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28879 
      for iter692 in self.success:
28880 
        iter692.write(oprot)
6154 rajveer 28881 
      oprot.writeListEnd()
28882 
      oprot.writeFieldEnd()
28883 
    oprot.writeFieldStop()
28884 
    oprot.writeStructEnd()
28885 
 
28886 
  def validate(self):
28887 
    return
28888 
 
28889 
 
28890 
  def __repr__(self):
28891 
    L = ['%s=%r' % (key, value)
28892 
      for key, value in self.__dict__.iteritems()]
28893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28894 
 
28895 
  def __eq__(self, other):
28896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28897 
 
28898 
  def __ne__(self, other):
28899 
    return not (self == other)
6159 rajveer 28900 
 
28901 
class getPlansForOperator_args:
28902 
  """
28903 
  Attributes:
28904 
   - operatorId
28905 
  """
28906 
 
28907 
  thrift_spec = (
28908 
    None, # 0
28909 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28910 
  )
28911 
 
28912 
  def __init__(self, operatorId=None,):
28913 
    self.operatorId = operatorId
28914 
 
28915 
  def read(self, iprot):
28916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28918 
      return
28919 
    iprot.readStructBegin()
28920 
    while True:
28921 
      (fname, ftype, fid) = iprot.readFieldBegin()
28922 
      if ftype == TType.STOP:
28923 
        break
28924 
      if fid == 1:
28925 
        if ftype == TType.I64:
28926 
          self.operatorId = iprot.readI64();
28927 
        else:
28928 
          iprot.skip(ftype)
28929 
      else:
28930 
        iprot.skip(ftype)
28931 
      iprot.readFieldEnd()
28932 
    iprot.readStructEnd()
28933 
 
28934 
  def write(self, oprot):
28935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28937 
      return
28938 
    oprot.writeStructBegin('getPlansForOperator_args')
28939 
    if self.operatorId is not None:
28940 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28941 
      oprot.writeI64(self.operatorId)
28942 
      oprot.writeFieldEnd()
28943 
    oprot.writeFieldStop()
28944 
    oprot.writeStructEnd()
28945 
 
28946 
  def validate(self):
28947 
    return
28948 
 
28949 
 
28950 
  def __repr__(self):
28951 
    L = ['%s=%r' % (key, value)
28952 
      for key, value in self.__dict__.iteritems()]
28953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28954 
 
28955 
  def __eq__(self, other):
28956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28957 
 
28958 
  def __ne__(self, other):
28959 
    return not (self == other)
28960 
 
28961 
class getPlansForOperator_result:
28962 
  """
28963 
  Attributes:
28964 
   - success
28965 
  """
28966 
 
28967 
  thrift_spec = (
28968 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28969 
  )
28970 
 
28971 
  def __init__(self, success=None,):
28972 
    self.success = success
28973 
 
28974 
  def read(self, iprot):
28975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28977 
      return
28978 
    iprot.readStructBegin()
28979 
    while True:
28980 
      (fname, ftype, fid) = iprot.readFieldBegin()
28981 
      if ftype == TType.STOP:
28982 
        break
28983 
      if fid == 0:
28984 
        if ftype == TType.LIST:
28985 
          self.success = []
6188 rajveer 28986 
          (_etype696, _size693) = iprot.readListBegin()
28987 
          for _i697 in xrange(_size693):
28988 
            _elem698 = RechargePlan()
28989 
            _elem698.read(iprot)
28990 
            self.success.append(_elem698)
6159 rajveer 28991 
          iprot.readListEnd()
28992 
        else:
28993 
          iprot.skip(ftype)
28994 
      else:
28995 
        iprot.skip(ftype)
28996 
      iprot.readFieldEnd()
28997 
    iprot.readStructEnd()
28998 
 
28999 
  def write(self, oprot):
29000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29002 
      return
29003 
    oprot.writeStructBegin('getPlansForOperator_result')
29004 
    if self.success is not None:
29005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29007 
      for iter699 in self.success:
29008 
        iter699.write(oprot)
6159 rajveer 29009 
      oprot.writeListEnd()
29010 
      oprot.writeFieldEnd()
29011 
    oprot.writeFieldStop()
29012 
    oprot.writeStructEnd()
29013 
 
29014 
  def validate(self):
29015 
    return
29016 
 
29017 
 
29018 
  def __repr__(self):
29019 
    L = ['%s=%r' % (key, value)
29020 
      for key, value in self.__dict__.iteritems()]
29021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29022 
 
29023 
  def __eq__(self, other):
29024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29025 
 
29026 
  def __ne__(self, other):
29027 
    return not (self == other)
6289 anupam.sin 29028 
 
29029 
class getRechargeDenominations_args:
29030 
  """
29031 
  Attributes:
29032 
   - operatorId
6307 anupam.sin 29033 
   - circleCode
6289 anupam.sin 29034 
   - denominationType
29035 
  """
29036 
 
29037 
  thrift_spec = (
29038 
    None, # 0
29039 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29040 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29041 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29042 
  )
29043 
 
6307 anupam.sin 29044 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29045 
    self.operatorId = operatorId
6307 anupam.sin 29046 
    self.circleCode = circleCode
6289 anupam.sin 29047 
    self.denominationType = denominationType
29048 
 
29049 
  def read(self, iprot):
29050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29052 
      return
29053 
    iprot.readStructBegin()
29054 
    while True:
29055 
      (fname, ftype, fid) = iprot.readFieldBegin()
29056 
      if ftype == TType.STOP:
29057 
        break
29058 
      if fid == 1:
29059 
        if ftype == TType.I64:
29060 
          self.operatorId = iprot.readI64();
29061 
        else:
29062 
          iprot.skip(ftype)
29063 
      elif fid == 2:
29064 
        if ftype == TType.STRING:
6307 anupam.sin 29065 
          self.circleCode = iprot.readString();
6289 anupam.sin 29066 
        else:
29067 
          iprot.skip(ftype)
29068 
      elif fid == 3:
29069 
        if ftype == TType.I32:
29070 
          self.denominationType = iprot.readI32();
29071 
        else:
29072 
          iprot.skip(ftype)
29073 
      else:
29074 
        iprot.skip(ftype)
29075 
      iprot.readFieldEnd()
29076 
    iprot.readStructEnd()
29077 
 
29078 
  def write(self, oprot):
29079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29081 
      return
29082 
    oprot.writeStructBegin('getRechargeDenominations_args')
29083 
    if self.operatorId is not None:
29084 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29085 
      oprot.writeI64(self.operatorId)
29086 
      oprot.writeFieldEnd()
6307 anupam.sin 29087 
    if self.circleCode is not None:
29088 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29089 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29090 
      oprot.writeFieldEnd()
29091 
    if self.denominationType is not None:
29092 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29093 
      oprot.writeI32(self.denominationType)
29094 
      oprot.writeFieldEnd()
29095 
    oprot.writeFieldStop()
29096 
    oprot.writeStructEnd()
29097 
 
29098 
  def validate(self):
29099 
    return
29100 
 
29101 
 
29102 
  def __repr__(self):
29103 
    L = ['%s=%r' % (key, value)
29104 
      for key, value in self.__dict__.iteritems()]
29105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29106 
 
29107 
  def __eq__(self, other):
29108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29109 
 
29110 
  def __ne__(self, other):
29111 
    return not (self == other)
29112 
 
29113 
class getRechargeDenominations_result:
29114 
  """
29115 
  Attributes:
29116 
   - success
29117 
   - ex
29118 
  """
29119 
 
29120 
  thrift_spec = (
29121 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29122 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29123 
  )
29124 
 
29125 
  def __init__(self, success=None, ex=None,):
29126 
    self.success = success
29127 
    self.ex = ex
29128 
 
29129 
  def read(self, iprot):
29130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29132 
      return
29133 
    iprot.readStructBegin()
29134 
    while True:
29135 
      (fname, ftype, fid) = iprot.readFieldBegin()
29136 
      if ftype == TType.STOP:
29137 
        break
29138 
      if fid == 0:
29139 
        if ftype == TType.LIST:
29140 
          self.success = []
29141 
          (_etype703, _size700) = iprot.readListBegin()
29142 
          for _i704 in xrange(_size700):
29143 
            _elem705 = RechargeDenomination()
29144 
            _elem705.read(iprot)
29145 
            self.success.append(_elem705)
29146 
          iprot.readListEnd()
29147 
        else:
29148 
          iprot.skip(ftype)
29149 
      elif fid == 1:
29150 
        if ftype == TType.STRUCT:
29151 
          self.ex = TransactionServiceException()
29152 
          self.ex.read(iprot)
29153 
        else:
29154 
          iprot.skip(ftype)
29155 
      else:
29156 
        iprot.skip(ftype)
29157 
      iprot.readFieldEnd()
29158 
    iprot.readStructEnd()
29159 
 
29160 
  def write(self, oprot):
29161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29163 
      return
29164 
    oprot.writeStructBegin('getRechargeDenominations_result')
29165 
    if self.success is not None:
29166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29168 
      for iter706 in self.success:
29169 
        iter706.write(oprot)
29170 
      oprot.writeListEnd()
29171 
      oprot.writeFieldEnd()
29172 
    if self.ex is not None:
29173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29174 
      self.ex.write(oprot)
29175 
      oprot.writeFieldEnd()
29176 
    oprot.writeFieldStop()
29177 
    oprot.writeStructEnd()
29178 
 
29179 
  def validate(self):
29180 
    return
29181 
 
29182 
 
29183 
  def __repr__(self):
29184 
    L = ['%s=%r' % (key, value)
29185 
      for key, value in self.__dict__.iteritems()]
29186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29187 
 
29188 
  def __eq__(self, other):
29189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29190 
 
29191 
  def __ne__(self, other):
29192 
    return not (self == other)
6371 rajveer 29193 
 
29194 
class updateAvailabilityStatus_args:
29195 
  """
29196 
  Attributes:
29197 
   - operatorId
29198 
   - circleId
29199 
   - isAvailable
29200 
  """
29201 
 
29202 
  thrift_spec = (
29203 
    None, # 0
29204 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29205 
    (2, TType.I64, 'circleId', None, None, ), # 2
29206 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29207 
  )
29208 
 
29209 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29210 
    self.operatorId = operatorId
29211 
    self.circleId = circleId
29212 
    self.isAvailable = isAvailable
29213 
 
29214 
  def read(self, iprot):
29215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29217 
      return
29218 
    iprot.readStructBegin()
29219 
    while True:
29220 
      (fname, ftype, fid) = iprot.readFieldBegin()
29221 
      if ftype == TType.STOP:
29222 
        break
29223 
      if fid == 1:
29224 
        if ftype == TType.I64:
29225 
          self.operatorId = iprot.readI64();
29226 
        else:
29227 
          iprot.skip(ftype)
29228 
      elif fid == 2:
29229 
        if ftype == TType.I64:
29230 
          self.circleId = iprot.readI64();
29231 
        else:
29232 
          iprot.skip(ftype)
29233 
      elif fid == 3:
29234 
        if ftype == TType.BOOL:
29235 
          self.isAvailable = iprot.readBool();
29236 
        else:
29237 
          iprot.skip(ftype)
29238 
      else:
29239 
        iprot.skip(ftype)
29240 
      iprot.readFieldEnd()
29241 
    iprot.readStructEnd()
29242 
 
29243 
  def write(self, oprot):
29244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29246 
      return
29247 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29248 
    if self.operatorId is not None:
29249 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29250 
      oprot.writeI64(self.operatorId)
29251 
      oprot.writeFieldEnd()
29252 
    if self.circleId is not None:
29253 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29254 
      oprot.writeI64(self.circleId)
29255 
      oprot.writeFieldEnd()
29256 
    if self.isAvailable is not None:
29257 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29258 
      oprot.writeBool(self.isAvailable)
29259 
      oprot.writeFieldEnd()
29260 
    oprot.writeFieldStop()
29261 
    oprot.writeStructEnd()
29262 
 
29263 
  def validate(self):
29264 
    return
29265 
 
29266 
 
29267 
  def __repr__(self):
29268 
    L = ['%s=%r' % (key, value)
29269 
      for key, value in self.__dict__.iteritems()]
29270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29271 
 
29272 
  def __eq__(self, other):
29273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29274 
 
29275 
  def __ne__(self, other):
29276 
    return not (self == other)
29277 
 
29278 
class updateAvailabilityStatus_result:
29279 
 
29280 
  thrift_spec = (
29281 
  )
29282 
 
29283 
  def read(self, iprot):
29284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29286 
      return
29287 
    iprot.readStructBegin()
29288 
    while True:
29289 
      (fname, ftype, fid) = iprot.readFieldBegin()
29290 
      if ftype == TType.STOP:
29291 
        break
29292 
      else:
29293 
        iprot.skip(ftype)
29294 
      iprot.readFieldEnd()
29295 
    iprot.readStructEnd()
29296 
 
29297 
  def write(self, oprot):
29298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29300 
      return
29301 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29302 
    oprot.writeFieldStop()
29303 
    oprot.writeStructEnd()
29304 
 
29305 
  def validate(self):
29306 
    return
29307 
 
29308 
 
29309 
  def __repr__(self):
29310 
    L = ['%s=%r' % (key, value)
29311 
      for key, value in self.__dict__.iteritems()]
29312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29313 
 
29314 
  def __eq__(self, other):
29315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29316 
 
29317 
  def __ne__(self, other):
29318 
    return not (self == other)
6389 rajveer 29319 
 
29320 
class getAvailableEmiSchemes_args:
29321 
 
29322 
  thrift_spec = (
29323 
  )
29324 
 
29325 
  def read(self, iprot):
29326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29328 
      return
29329 
    iprot.readStructBegin()
29330 
    while True:
29331 
      (fname, ftype, fid) = iprot.readFieldBegin()
29332 
      if ftype == TType.STOP:
29333 
        break
29334 
      else:
29335 
        iprot.skip(ftype)
29336 
      iprot.readFieldEnd()
29337 
    iprot.readStructEnd()
29338 
 
29339 
  def write(self, oprot):
29340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29342 
      return
29343 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29344 
    oprot.writeFieldStop()
29345 
    oprot.writeStructEnd()
29346 
 
29347 
  def validate(self):
29348 
    return
29349 
 
29350 
 
29351 
  def __repr__(self):
29352 
    L = ['%s=%r' % (key, value)
29353 
      for key, value in self.__dict__.iteritems()]
29354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29355 
 
29356 
  def __eq__(self, other):
29357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29358 
 
29359 
  def __ne__(self, other):
29360 
    return not (self == other)
29361 
 
29362 
class getAvailableEmiSchemes_result:
29363 
  """
29364 
  Attributes:
29365 
   - success
29366 
  """
29367 
 
29368 
  thrift_spec = (
29369 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29370 
  )
29371 
 
29372 
  def __init__(self, success=None,):
29373 
    self.success = success
29374 
 
29375 
  def read(self, iprot):
29376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29378 
      return
29379 
    iprot.readStructBegin()
29380 
    while True:
29381 
      (fname, ftype, fid) = iprot.readFieldBegin()
29382 
      if ftype == TType.STOP:
29383 
        break
29384 
      if fid == 0:
29385 
        if ftype == TType.LIST:
29386 
          self.success = []
29387 
          (_etype710, _size707) = iprot.readListBegin()
29388 
          for _i711 in xrange(_size707):
29389 
            _elem712 = EmiScheme()
29390 
            _elem712.read(iprot)
29391 
            self.success.append(_elem712)
29392 
          iprot.readListEnd()
29393 
        else:
29394 
          iprot.skip(ftype)
29395 
      else:
29396 
        iprot.skip(ftype)
29397 
      iprot.readFieldEnd()
29398 
    iprot.readStructEnd()
29399 
 
29400 
  def write(self, oprot):
29401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29403 
      return
29404 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29405 
    if self.success is not None:
29406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29408 
      for iter713 in self.success:
29409 
        iter713.write(oprot)
29410 
      oprot.writeListEnd()
29411 
      oprot.writeFieldEnd()
29412 
    oprot.writeFieldStop()
29413 
    oprot.writeStructEnd()
29414 
 
29415 
  def validate(self):
29416 
    return
29417 
 
29418 
 
29419 
  def __repr__(self):
29420 
    L = ['%s=%r' % (key, value)
29421 
      for key, value in self.__dict__.iteritems()]
29422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29423 
 
29424 
  def __eq__(self, other):
29425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29426 
 
29427 
  def __ne__(self, other):
29428 
    return not (self == other)
29429 
 
29430 
class getMiscCharges_args:
29431 
  """
29432 
  Attributes:
29433 
   - transactionId
29434 
  """
29435 
 
29436 
  thrift_spec = (
29437 
    None, # 0
29438 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29439 
  )
29440 
 
29441 
  def __init__(self, transactionId=None,):
29442 
    self.transactionId = transactionId
29443 
 
29444 
  def read(self, iprot):
29445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29447 
      return
29448 
    iprot.readStructBegin()
29449 
    while True:
29450 
      (fname, ftype, fid) = iprot.readFieldBegin()
29451 
      if ftype == TType.STOP:
29452 
        break
29453 
      if fid == 1:
29454 
        if ftype == TType.I64:
29455 
          self.transactionId = iprot.readI64();
29456 
        else:
29457 
          iprot.skip(ftype)
29458 
      else:
29459 
        iprot.skip(ftype)
29460 
      iprot.readFieldEnd()
29461 
    iprot.readStructEnd()
29462 
 
29463 
  def write(self, oprot):
29464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29466 
      return
29467 
    oprot.writeStructBegin('getMiscCharges_args')
29468 
    if self.transactionId is not None:
29469 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29470 
      oprot.writeI64(self.transactionId)
29471 
      oprot.writeFieldEnd()
29472 
    oprot.writeFieldStop()
29473 
    oprot.writeStructEnd()
29474 
 
29475 
  def validate(self):
29476 
    return
29477 
 
29478 
 
29479 
  def __repr__(self):
29480 
    L = ['%s=%r' % (key, value)
29481 
      for key, value in self.__dict__.iteritems()]
29482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29483 
 
29484 
  def __eq__(self, other):
29485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29486 
 
29487 
  def __ne__(self, other):
29488 
    return not (self == other)
29489 
 
29490 
class getMiscCharges_result:
29491 
  """
29492 
  Attributes:
29493 
   - success
29494 
  """
29495 
 
29496 
  thrift_spec = (
6412 rajveer 29497 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29498 
  )
29499 
 
29500 
  def __init__(self, success=None,):
29501 
    self.success = success
29502 
 
29503 
  def read(self, iprot):
29504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29506 
      return
29507 
    iprot.readStructBegin()
29508 
    while True:
29509 
      (fname, ftype, fid) = iprot.readFieldBegin()
29510 
      if ftype == TType.STOP:
29511 
        break
29512 
      if fid == 0:
29513 
        if ftype == TType.MAP:
29514 
          self.success = {}
29515 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29516 
          for _i718 in xrange(_size714):
29517 
            _key719 = iprot.readI64();
6412 rajveer 29518 
            _val720 = iprot.readDouble();
6389 rajveer 29519 
            self.success[_key719] = _val720
29520 
          iprot.readMapEnd()
29521 
        else:
29522 
          iprot.skip(ftype)
29523 
      else:
29524 
        iprot.skip(ftype)
29525 
      iprot.readFieldEnd()
29526 
    iprot.readStructEnd()
29527 
 
29528 
  def write(self, oprot):
29529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29531 
      return
29532 
    oprot.writeStructBegin('getMiscCharges_result')
29533 
    if self.success is not None:
29534 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29535 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29536 
      for kiter721,viter722 in self.success.items():
29537 
        oprot.writeI64(kiter721)
6412 rajveer 29538 
        oprot.writeDouble(viter722)
6389 rajveer 29539 
      oprot.writeMapEnd()
29540 
      oprot.writeFieldEnd()
29541 
    oprot.writeFieldStop()
29542 
    oprot.writeStructEnd()
29543 
 
29544 
  def validate(self):
29545 
    return
29546 
 
29547 
 
29548 
  def __repr__(self):
29549 
    L = ['%s=%r' % (key, value)
29550 
      for key, value in self.__dict__.iteritems()]
29551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29552 
 
29553 
  def __eq__(self, other):
29554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29555 
 
29556 
  def __ne__(self, other):
29557 
    return not (self == other)
6507 anupam.sin 29558 
 
29559 
class refundRechargeOrder_args:
29560 
  """
29561 
  Attributes:
29562 
   - rechargeOrderId
29563 
  """
29564 
 
29565 
  thrift_spec = (
29566 
    None, # 0
29567 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29568 
  )
29569 
 
29570 
  def __init__(self, rechargeOrderId=None,):
29571 
    self.rechargeOrderId = rechargeOrderId
29572 
 
29573 
  def read(self, iprot):
29574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29576 
      return
29577 
    iprot.readStructBegin()
29578 
    while True:
29579 
      (fname, ftype, fid) = iprot.readFieldBegin()
29580 
      if ftype == TType.STOP:
29581 
        break
29582 
      if fid == 1:
29583 
        if ftype == TType.I64:
29584 
          self.rechargeOrderId = iprot.readI64();
29585 
        else:
29586 
          iprot.skip(ftype)
29587 
      else:
29588 
        iprot.skip(ftype)
29589 
      iprot.readFieldEnd()
29590 
    iprot.readStructEnd()
29591 
 
29592 
  def write(self, oprot):
29593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29595 
      return
29596 
    oprot.writeStructBegin('refundRechargeOrder_args')
29597 
    if self.rechargeOrderId is not None:
29598 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29599 
      oprot.writeI64(self.rechargeOrderId)
29600 
      oprot.writeFieldEnd()
29601 
    oprot.writeFieldStop()
29602 
    oprot.writeStructEnd()
29603 
 
29604 
  def validate(self):
29605 
    return
29606 
 
29607 
 
29608 
  def __repr__(self):
29609 
    L = ['%s=%r' % (key, value)
29610 
      for key, value in self.__dict__.iteritems()]
29611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29612 
 
29613 
  def __eq__(self, other):
29614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29615 
 
29616 
  def __ne__(self, other):
29617 
    return not (self == other)
29618 
 
29619 
class refundRechargeOrder_result:
29620 
  """
29621 
  Attributes:
29622 
   - success
29623 
   - ex
29624 
  """
29625 
 
29626 
  thrift_spec = (
29627 
    (0, TType.BOOL, 'success', None, None, ), # 0
29628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29629 
  )
29630 
 
29631 
  def __init__(self, success=None, ex=None,):
29632 
    self.success = success
29633 
    self.ex = ex
29634 
 
29635 
  def read(self, iprot):
29636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29638 
      return
29639 
    iprot.readStructBegin()
29640 
    while True:
29641 
      (fname, ftype, fid) = iprot.readFieldBegin()
29642 
      if ftype == TType.STOP:
29643 
        break
29644 
      if fid == 0:
29645 
        if ftype == TType.BOOL:
29646 
          self.success = iprot.readBool();
29647 
        else:
29648 
          iprot.skip(ftype)
29649 
      elif fid == 1:
29650 
        if ftype == TType.STRUCT:
29651 
          self.ex = TransactionServiceException()
29652 
          self.ex.read(iprot)
29653 
        else:
29654 
          iprot.skip(ftype)
29655 
      else:
29656 
        iprot.skip(ftype)
29657 
      iprot.readFieldEnd()
29658 
    iprot.readStructEnd()
29659 
 
29660 
  def write(self, oprot):
29661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29663 
      return
29664 
    oprot.writeStructBegin('refundRechargeOrder_result')
29665 
    if self.success is not None:
29666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29667 
      oprot.writeBool(self.success)
29668 
      oprot.writeFieldEnd()
29669 
    if self.ex is not None:
29670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29671 
      self.ex.write(oprot)
29672 
      oprot.writeFieldEnd()
29673 
    oprot.writeFieldStop()
29674 
    oprot.writeStructEnd()
29675 
 
29676 
  def validate(self):
29677 
    return
29678 
 
29679 
 
29680 
  def __repr__(self):
29681 
    L = ['%s=%r' % (key, value)
29682 
      for key, value in self.__dict__.iteritems()]
29683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29684 
 
29685 
  def __eq__(self, other):
29686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29687 
 
29688 
  def __ne__(self, other):
29689 
    return not (self == other)
6821 amar.kumar 29690 
 
29691 
class getPhysicalOrders_args:
29692 
  """
29693 
  Attributes:
29694 
   - fromDate
29695 
   - toDate
29696 
  """
29697 
 
29698 
  thrift_spec = (
29699 
    None, # 0
29700 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29701 
    (2, TType.I64, 'toDate', None, None, ), # 2
29702 
  )
29703 
 
29704 
  def __init__(self, fromDate=None, toDate=None,):
29705 
    self.fromDate = fromDate
29706 
    self.toDate = toDate
29707 
 
29708 
  def read(self, iprot):
29709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29711 
      return
29712 
    iprot.readStructBegin()
29713 
    while True:
29714 
      (fname, ftype, fid) = iprot.readFieldBegin()
29715 
      if ftype == TType.STOP:
29716 
        break
29717 
      if fid == 1:
29718 
        if ftype == TType.I64:
29719 
          self.fromDate = iprot.readI64();
29720 
        else:
29721 
          iprot.skip(ftype)
29722 
      elif fid == 2:
29723 
        if ftype == TType.I64:
29724 
          self.toDate = iprot.readI64();
29725 
        else:
29726 
          iprot.skip(ftype)
29727 
      else:
29728 
        iprot.skip(ftype)
29729 
      iprot.readFieldEnd()
29730 
    iprot.readStructEnd()
29731 
 
29732 
  def write(self, oprot):
29733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29735 
      return
29736 
    oprot.writeStructBegin('getPhysicalOrders_args')
29737 
    if self.fromDate is not None:
29738 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29739 
      oprot.writeI64(self.fromDate)
29740 
      oprot.writeFieldEnd()
29741 
    if self.toDate is not None:
29742 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29743 
      oprot.writeI64(self.toDate)
29744 
      oprot.writeFieldEnd()
29745 
    oprot.writeFieldStop()
29746 
    oprot.writeStructEnd()
29747 
 
29748 
  def validate(self):
29749 
    return
29750 
 
29751 
 
29752 
  def __repr__(self):
29753 
    L = ['%s=%r' % (key, value)
29754 
      for key, value in self.__dict__.iteritems()]
29755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29756 
 
29757 
  def __eq__(self, other):
29758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29759 
 
29760 
  def __ne__(self, other):
29761 
    return not (self == other)
29762 
 
29763 
class getPhysicalOrders_result:
29764 
  """
29765 
  Attributes:
29766 
   - success
29767 
  """
29768 
 
29769 
  thrift_spec = (
29770 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29771 
  )
29772 
 
29773 
  def __init__(self, success=None,):
29774 
    self.success = success
29775 
 
29776 
  def read(self, iprot):
29777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29779 
      return
29780 
    iprot.readStructBegin()
29781 
    while True:
29782 
      (fname, ftype, fid) = iprot.readFieldBegin()
29783 
      if ftype == TType.STOP:
29784 
        break
29785 
      if fid == 0:
29786 
        if ftype == TType.LIST:
29787 
          self.success = []
29788 
          (_etype726, _size723) = iprot.readListBegin()
29789 
          for _i727 in xrange(_size723):
29790 
            _elem728 = Order()
29791 
            _elem728.read(iprot)
29792 
            self.success.append(_elem728)
29793 
          iprot.readListEnd()
29794 
        else:
29795 
          iprot.skip(ftype)
29796 
      else:
29797 
        iprot.skip(ftype)
29798 
      iprot.readFieldEnd()
29799 
    iprot.readStructEnd()
29800 
 
29801 
  def write(self, oprot):
29802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29804 
      return
29805 
    oprot.writeStructBegin('getPhysicalOrders_result')
29806 
    if self.success is not None:
29807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29808 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29809 
      for iter729 in self.success:
29810 
        iter729.write(oprot)
29811 
      oprot.writeListEnd()
29812 
      oprot.writeFieldEnd()
29813 
    oprot.writeFieldStop()
29814 
    oprot.writeStructEnd()
29815 
 
29816 
  def validate(self):
29817 
    return
29818 
 
29819 
 
29820 
  def __repr__(self):
29821 
    L = ['%s=%r' % (key, value)
29822 
      for key, value in self.__dict__.iteritems()]
29823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29824 
 
29825 
  def __eq__(self, other):
29826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29827 
 
29828 
  def __ne__(self, other):
29829 
    return not (self == other)
6906 rajveer 29830 
 
29831 
class getDocument_args:
29832 
  """
29833 
  Attributes:
29834 
   - docType
29835 
   - docSource
29836 
  """
29837 
 
29838 
  thrift_spec = (
29839 
    None, # 0
29840 
    (1, TType.I64, 'docType', None, None, ), # 1
29841 
    (2, TType.I64, 'docSource', None, None, ), # 2
29842 
  )
29843 
 
29844 
  def __init__(self, docType=None, docSource=None,):
29845 
    self.docType = docType
29846 
    self.docSource = docSource
29847 
 
29848 
  def read(self, iprot):
29849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29851 
      return
29852 
    iprot.readStructBegin()
29853 
    while True:
29854 
      (fname, ftype, fid) = iprot.readFieldBegin()
29855 
      if ftype == TType.STOP:
29856 
        break
29857 
      if fid == 1:
29858 
        if ftype == TType.I64:
29859 
          self.docType = iprot.readI64();
29860 
        else:
29861 
          iprot.skip(ftype)
29862 
      elif fid == 2:
29863 
        if ftype == TType.I64:
29864 
          self.docSource = iprot.readI64();
29865 
        else:
29866 
          iprot.skip(ftype)
29867 
      else:
29868 
        iprot.skip(ftype)
29869 
      iprot.readFieldEnd()
29870 
    iprot.readStructEnd()
29871 
 
29872 
  def write(self, oprot):
29873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29875 
      return
29876 
    oprot.writeStructBegin('getDocument_args')
29877 
    if self.docType is not None:
29878 
      oprot.writeFieldBegin('docType', TType.I64, 1)
29879 
      oprot.writeI64(self.docType)
29880 
      oprot.writeFieldEnd()
29881 
    if self.docSource is not None:
29882 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
29883 
      oprot.writeI64(self.docSource)
29884 
      oprot.writeFieldEnd()
29885 
    oprot.writeFieldStop()
29886 
    oprot.writeStructEnd()
29887 
 
29888 
  def validate(self):
29889 
    return
29890 
 
29891 
 
29892 
  def __repr__(self):
29893 
    L = ['%s=%r' % (key, value)
29894 
      for key, value in self.__dict__.iteritems()]
29895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29896 
 
29897 
  def __eq__(self, other):
29898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29899 
 
29900 
  def __ne__(self, other):
29901 
    return not (self == other)
29902 
 
29903 
class getDocument_result:
29904 
  """
29905 
  Attributes:
29906 
   - success
29907 
  """
29908 
 
29909 
  thrift_spec = (
29910 
    (0, TType.STRING, 'success', None, None, ), # 0
29911 
  )
29912 
 
29913 
  def __init__(self, success=None,):
29914 
    self.success = success
29915 
 
29916 
  def read(self, iprot):
29917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29919 
      return
29920 
    iprot.readStructBegin()
29921 
    while True:
29922 
      (fname, ftype, fid) = iprot.readFieldBegin()
29923 
      if ftype == TType.STOP:
29924 
        break
29925 
      if fid == 0:
29926 
        if ftype == TType.STRING:
29927 
          self.success = iprot.readString();
29928 
        else:
29929 
          iprot.skip(ftype)
29930 
      else:
29931 
        iprot.skip(ftype)
29932 
      iprot.readFieldEnd()
29933 
    iprot.readStructEnd()
29934 
 
29935 
  def write(self, oprot):
29936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29938 
      return
29939 
    oprot.writeStructBegin('getDocument_result')
29940 
    if self.success is not None:
29941 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29942 
      oprot.writeString(self.success)
29943 
      oprot.writeFieldEnd()
29944 
    oprot.writeFieldStop()
29945 
    oprot.writeStructEnd()
29946 
 
29947 
  def validate(self):
29948 
    return
29949 
 
29950 
 
29951 
  def __repr__(self):
29952 
    L = ['%s=%r' % (key, value)
29953 
      for key, value in self.__dict__.iteritems()]
29954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29955 
 
29956 
  def __eq__(self, other):
29957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29958 
 
29959 
  def __ne__(self, other):
29960 
    return not (self == other)
6985 anupam.sin 29961 
 
29962 
class changeShippingAddress_args:
29963 
  """
29964 
  Attributes:
29965 
   - orderId
29966 
   - line1
29967 
   - line2
29968 
   - city
29969 
   - state
29970 
   - pin
29971 
  """
29972 
 
29973 
  thrift_spec = (
29974 
    None, # 0
29975 
    (1, TType.I64, 'orderId', None, None, ), # 1
29976 
    (2, TType.STRING, 'line1', None, None, ), # 2
29977 
    (3, TType.STRING, 'line2', None, None, ), # 3
29978 
    (4, TType.STRING, 'city', None, None, ), # 4
29979 
    (5, TType.STRING, 'state', None, None, ), # 5
29980 
    (6, TType.STRING, 'pin', None, None, ), # 6
29981 
  )
29982 
 
29983 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
29984 
    self.orderId = orderId
29985 
    self.line1 = line1
29986 
    self.line2 = line2
29987 
    self.city = city
29988 
    self.state = state
29989 
    self.pin = pin
29990 
 
29991 
  def read(self, iprot):
29992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29994 
      return
29995 
    iprot.readStructBegin()
29996 
    while True:
29997 
      (fname, ftype, fid) = iprot.readFieldBegin()
29998 
      if ftype == TType.STOP:
29999 
        break
30000 
      if fid == 1:
30001 
        if ftype == TType.I64:
30002 
          self.orderId = iprot.readI64();
30003 
        else:
30004 
          iprot.skip(ftype)
30005 
      elif fid == 2:
30006 
        if ftype == TType.STRING:
30007 
          self.line1 = iprot.readString();
30008 
        else:
30009 
          iprot.skip(ftype)
30010 
      elif fid == 3:
30011 
        if ftype == TType.STRING:
30012 
          self.line2 = iprot.readString();
30013 
        else:
30014 
          iprot.skip(ftype)
30015 
      elif fid == 4:
30016 
        if ftype == TType.STRING:
30017 
          self.city = iprot.readString();
30018 
        else:
30019 
          iprot.skip(ftype)
30020 
      elif fid == 5:
30021 
        if ftype == TType.STRING:
30022 
          self.state = iprot.readString();
30023 
        else:
30024 
          iprot.skip(ftype)
30025 
      elif fid == 6:
30026 
        if ftype == TType.STRING:
30027 
          self.pin = iprot.readString();
30028 
        else:
30029 
          iprot.skip(ftype)
30030 
      else:
30031 
        iprot.skip(ftype)
30032 
      iprot.readFieldEnd()
30033 
    iprot.readStructEnd()
30034 
 
30035 
  def write(self, oprot):
30036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30038 
      return
30039 
    oprot.writeStructBegin('changeShippingAddress_args')
30040 
    if self.orderId is not None:
30041 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30042 
      oprot.writeI64(self.orderId)
30043 
      oprot.writeFieldEnd()
30044 
    if self.line1 is not None:
30045 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30046 
      oprot.writeString(self.line1)
30047 
      oprot.writeFieldEnd()
30048 
    if self.line2 is not None:
30049 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30050 
      oprot.writeString(self.line2)
30051 
      oprot.writeFieldEnd()
30052 
    if self.city is not None:
30053 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30054 
      oprot.writeString(self.city)
30055 
      oprot.writeFieldEnd()
30056 
    if self.state is not None:
30057 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30058 
      oprot.writeString(self.state)
30059 
      oprot.writeFieldEnd()
30060 
    if self.pin is not None:
30061 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30062 
      oprot.writeString(self.pin)
30063 
      oprot.writeFieldEnd()
30064 
    oprot.writeFieldStop()
30065 
    oprot.writeStructEnd()
30066 
 
30067 
  def validate(self):
30068 
    return
30069 
 
30070 
 
30071 
  def __repr__(self):
30072 
    L = ['%s=%r' % (key, value)
30073 
      for key, value in self.__dict__.iteritems()]
30074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30075 
 
30076 
  def __eq__(self, other):
30077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30078 
 
30079 
  def __ne__(self, other):
30080 
    return not (self == other)
30081 
 
30082 
class changeShippingAddress_result:
30083 
  """
30084 
  Attributes:
30085 
   - success
30086 
  """
30087 
 
30088 
  thrift_spec = (
30089 
    (0, TType.BOOL, 'success', None, None, ), # 0
30090 
  )
30091 
 
30092 
  def __init__(self, success=None,):
30093 
    self.success = success
30094 
 
30095 
  def read(self, iprot):
30096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30098 
      return
30099 
    iprot.readStructBegin()
30100 
    while True:
30101 
      (fname, ftype, fid) = iprot.readFieldBegin()
30102 
      if ftype == TType.STOP:
30103 
        break
30104 
      if fid == 0:
30105 
        if ftype == TType.BOOL:
30106 
          self.success = iprot.readBool();
30107 
        else:
30108 
          iprot.skip(ftype)
30109 
      else:
30110 
        iprot.skip(ftype)
30111 
      iprot.readFieldEnd()
30112 
    iprot.readStructEnd()
30113 
 
30114 
  def write(self, oprot):
30115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30117 
      return
30118 
    oprot.writeStructBegin('changeShippingAddress_result')
30119 
    if self.success is not None:
30120 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30121 
      oprot.writeBool(self.success)
30122 
      oprot.writeFieldEnd()
30123 
    oprot.writeFieldStop()
30124 
    oprot.writeStructEnd()
30125 
 
30126 
  def validate(self):
30127 
    return
30128 
 
30129 
 
30130 
  def __repr__(self):
30131 
    L = ['%s=%r' % (key, value)
30132 
      for key, value in self.__dict__.iteritems()]
30133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30134 
 
30135 
  def __eq__(self, other):
30136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30137 
 
30138 
  def __ne__(self, other):
30139 
    return not (self == other)
6988 rajveer 30140 
 
30141 
class retrieveInvoice_args:
30142 
  """
30143 
  Attributes:
30144 
   - orderId
30145 
  """
30146 
 
30147 
  thrift_spec = (
30148 
    None, # 0
30149 
    (1, TType.I64, 'orderId', None, None, ), # 1
30150 
  )
30151 
 
30152 
  def __init__(self, orderId=None,):
30153 
    self.orderId = orderId
30154 
 
30155 
  def read(self, iprot):
30156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30158 
      return
30159 
    iprot.readStructBegin()
30160 
    while True:
30161 
      (fname, ftype, fid) = iprot.readFieldBegin()
30162 
      if ftype == TType.STOP:
30163 
        break
30164 
      if fid == 1:
30165 
        if ftype == TType.I64:
30166 
          self.orderId = iprot.readI64();
30167 
        else:
30168 
          iprot.skip(ftype)
30169 
      else:
30170 
        iprot.skip(ftype)
30171 
      iprot.readFieldEnd()
30172 
    iprot.readStructEnd()
30173 
 
30174 
  def write(self, oprot):
30175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30177 
      return
30178 
    oprot.writeStructBegin('retrieveInvoice_args')
30179 
    if self.orderId is not None:
30180 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30181 
      oprot.writeI64(self.orderId)
30182 
      oprot.writeFieldEnd()
30183 
    oprot.writeFieldStop()
30184 
    oprot.writeStructEnd()
30185 
 
30186 
  def validate(self):
30187 
    return
30188 
 
30189 
 
30190 
  def __repr__(self):
30191 
    L = ['%s=%r' % (key, value)
30192 
      for key, value in self.__dict__.iteritems()]
30193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30194 
 
30195 
  def __eq__(self, other):
30196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30197 
 
30198 
  def __ne__(self, other):
30199 
    return not (self == other)
30200 
 
30201 
class retrieveInvoice_result:
30202 
  """
30203 
  Attributes:
30204 
   - success
30205 
  """
30206 
 
30207 
  thrift_spec = (
30208 
    (0, TType.STRING, 'success', None, None, ), # 0
30209 
  )
30210 
 
30211 
  def __init__(self, success=None,):
30212 
    self.success = success
30213 
 
30214 
  def read(self, iprot):
30215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30217 
      return
30218 
    iprot.readStructBegin()
30219 
    while True:
30220 
      (fname, ftype, fid) = iprot.readFieldBegin()
30221 
      if ftype == TType.STOP:
30222 
        break
30223 
      if fid == 0:
30224 
        if ftype == TType.STRING:
30225 
          self.success = iprot.readString();
30226 
        else:
30227 
          iprot.skip(ftype)
30228 
      else:
30229 
        iprot.skip(ftype)
30230 
      iprot.readFieldEnd()
30231 
    iprot.readStructEnd()
30232 
 
30233 
  def write(self, oprot):
30234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30236 
      return
30237 
    oprot.writeStructBegin('retrieveInvoice_result')
30238 
    if self.success is not None:
30239 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30240 
      oprot.writeString(self.success)
30241 
      oprot.writeFieldEnd()
30242 
    oprot.writeFieldStop()
30243 
    oprot.writeStructEnd()
30244 
 
30245 
  def validate(self):
30246 
    return
30247 
 
30248 
 
30249 
  def __repr__(self):
30250 
    L = ['%s=%r' % (key, value)
30251 
      for key, value in self.__dict__.iteritems()]
30252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30253 
 
30254 
  def __eq__(self, other):
30255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30256 
 
30257 
  def __ne__(self, other):
30258 
    return not (self == other)