Subversion Repositories SmartDukaan

Rev

Rev 6756 | Rev 6906 | 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 
 
6821 amar.kumar 1455 
 
3376 rajveer 1456 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1457 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1458 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1459 
 
1460 
  def createTransaction(self, transaction):
1461 
    """
1462 
    Parameters:
1463 
     - transaction
1464 
    """
1465 
    self.send_createTransaction(transaction)
132 ashish 1466 
    return self.recv_createTransaction()
94 ashish 1467 
 
1468 
  def send_createTransaction(self, transaction):
1469 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1470 
    args = createTransaction_args()
1471 
    args.transaction = transaction
1472 
    args.write(self._oprot)
1473 
    self._oprot.writeMessageEnd()
1474 
    self._oprot.trans.flush()
1475 
 
1476 
  def recv_createTransaction(self, ):
1477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1478 
    if mtype == TMessageType.EXCEPTION:
1479 
      x = TApplicationException()
1480 
      x.read(self._iprot)
1481 
      self._iprot.readMessageEnd()
1482 
      raise x
1483 
    result = createTransaction_result()
1484 
    result.read(self._iprot)
1485 
    self._iprot.readMessageEnd()
3431 rajveer 1486 
    if result.success is not None:
132 ashish 1487 
      return result.success
3431 rajveer 1488 
    if result.ex is not None:
94 ashish 1489 
      raise result.ex
132 ashish 1490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1491 
 
1492 
  def getTransaction(self, id):
1493 
    """
1494 
    Parameters:
1495 
     - id
1496 
    """
1497 
    self.send_getTransaction(id)
1498 
    return self.recv_getTransaction()
1499 
 
1500 
  def send_getTransaction(self, id):
1501 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1502 
    args = getTransaction_args()
1503 
    args.id = id
1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
1508 
  def recv_getTransaction(self, ):
1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
1515 
    result = getTransaction_result()
1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
3431 rajveer 1518 
    if result.success is not None:
94 ashish 1519 
      return result.success
3431 rajveer 1520 
    if result.ex is not None:
94 ashish 1521 
      raise result.ex
1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1523 
 
1524 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1525 
    """
1526 
    Parameters:
1527 
     - customerId
1528 
     - from_date
1529 
     - to_date
1530 
     - status
1531 
    """
1532 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1533 
    return self.recv_getTransactionsForCustomer()
1534 
 
1535 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1536 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1537 
    args = getTransactionsForCustomer_args()
1538 
    args.customerId = customerId
1539 
    args.from_date = from_date
1540 
    args.to_date = to_date
1541 
    args.status = status
1542 
    args.write(self._oprot)
1543 
    self._oprot.writeMessageEnd()
1544 
    self._oprot.trans.flush()
1545 
 
1546 
  def recv_getTransactionsForCustomer(self, ):
1547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1548 
    if mtype == TMessageType.EXCEPTION:
1549 
      x = TApplicationException()
1550 
      x.read(self._iprot)
1551 
      self._iprot.readMessageEnd()
1552 
      raise x
1553 
    result = getTransactionsForCustomer_result()
1554 
    result.read(self._iprot)
1555 
    self._iprot.readMessageEnd()
3431 rajveer 1556 
    if result.success is not None:
94 ashish 1557 
      return result.success
3431 rajveer 1558 
    if result.ex is not None:
94 ashish 1559 
      raise result.ex
1560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1561 
 
132 ashish 1562 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1563 
    """
1564 
    Parameters:
1565 
     - shoppingCartId
1566 
    """
1567 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1568 
    return self.recv_getTransactionsForShoppingCartId()
1569 
 
1570 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1571 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1572 
    args = getTransactionsForShoppingCartId_args()
1573 
    args.shoppingCartId = shoppingCartId
1574 
    args.write(self._oprot)
1575 
    self._oprot.writeMessageEnd()
1576 
    self._oprot.trans.flush()
1577 
 
1578 
  def recv_getTransactionsForShoppingCartId(self, ):
1579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1580 
    if mtype == TMessageType.EXCEPTION:
1581 
      x = TApplicationException()
1582 
      x.read(self._iprot)
1583 
      self._iprot.readMessageEnd()
1584 
      raise x
1585 
    result = getTransactionsForShoppingCartId_result()
1586 
    result.read(self._iprot)
1587 
    self._iprot.readMessageEnd()
3431 rajveer 1588 
    if result.success is not None:
132 ashish 1589 
      return result.success
3431 rajveer 1590 
    if result.ex is not None:
132 ashish 1591 
      raise result.ex
1592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1593 
 
94 ashish 1594 
  def getTransactionStatus(self, transactionId):
1595 
    """
1596 
    Parameters:
1597 
     - transactionId
1598 
    """
1599 
    self.send_getTransactionStatus(transactionId)
1600 
    return self.recv_getTransactionStatus()
1601 
 
1602 
  def send_getTransactionStatus(self, transactionId):
1603 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1604 
    args = getTransactionStatus_args()
1605 
    args.transactionId = transactionId
1606 
    args.write(self._oprot)
1607 
    self._oprot.writeMessageEnd()
1608 
    self._oprot.trans.flush()
1609 
 
1610 
  def recv_getTransactionStatus(self, ):
1611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1612 
    if mtype == TMessageType.EXCEPTION:
1613 
      x = TApplicationException()
1614 
      x.read(self._iprot)
1615 
      self._iprot.readMessageEnd()
1616 
      raise x
1617 
    result = getTransactionStatus_result()
1618 
    result.read(self._iprot)
1619 
    self._iprot.readMessageEnd()
3431 rajveer 1620 
    if result.success is not None:
94 ashish 1621 
      return result.success
3431 rajveer 1622 
    if result.ex is not None:
94 ashish 1623 
      raise result.ex
1624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1625 
 
5527 anupam.sin 1626 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1627 
    """
1628 
    Parameters:
1629 
     - transactionId
1630 
     - status
1631 
     - description
5527 anupam.sin 1632 
     - pickUp
1633 
     - orderType
94 ashish 1634 
    """
5527 anupam.sin 1635 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1636 
    return self.recv_changeTransactionStatus()
1637 
 
5527 anupam.sin 1638 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1639 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1640 
    args = changeTransactionStatus_args()
1641 
    args.transactionId = transactionId
1642 
    args.status = status
1643 
    args.description = description
5527 anupam.sin 1644 
    args.pickUp = pickUp
1645 
    args.orderType = orderType
94 ashish 1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
1650 
  def recv_changeTransactionStatus(self, ):
1651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1652 
    if mtype == TMessageType.EXCEPTION:
1653 
      x = TApplicationException()
1654 
      x.read(self._iprot)
1655 
      self._iprot.readMessageEnd()
1656 
      raise x
1657 
    result = changeTransactionStatus_result()
1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
3431 rajveer 1660 
    if result.success is not None:
94 ashish 1661 
      return result.success
3431 rajveer 1662 
    if result.ex is not None:
94 ashish 1663 
      raise result.ex
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1665 
 
1398 varun.gupt 1666 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1667 
    """
1668 
    Parameters:
1669 
     - transactionId
1670 
    """
1398 varun.gupt 1671 
    self.send_enqueueTransactionInfoEmail(transactionId)
1672 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1673 
 
1398 varun.gupt 1674 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1675 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1676 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1677 
    args.transactionId = transactionId
1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
1398 varun.gupt 1682 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
1398 varun.gupt 1689 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
3431 rajveer 1692 
    if result.success is not None:
1382 varun.gupt 1693 
      return result.success
3431 rajveer 1694 
    if result.ex is not None:
1382 varun.gupt 1695 
      raise result.ex
1398 varun.gupt 1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1697 
 
4801 anupam.sin 1698 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1699 
    """
1700 
    Parameters:
4801 anupam.sin 1701 
     - statuses
483 rajveer 1702 
     - from_date
1703 
     - to_date
1704 
     - warehouse_id
94 ashish 1705 
    """
4801 anupam.sin 1706 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1707 
    return self.recv_getAllOrders()
94 ashish 1708 
 
4801 anupam.sin 1709 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1710 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1711 
    args = getAllOrders_args()
4801 anupam.sin 1712 
    args.statuses = statuses
483 rajveer 1713 
    args.from_date = from_date
1714 
    args.to_date = to_date
1715 
    args.warehouse_id = warehouse_id
94 ashish 1716 
    args.write(self._oprot)
1717 
    self._oprot.writeMessageEnd()
1718 
    self._oprot.trans.flush()
1719 
 
483 rajveer 1720 
  def recv_getAllOrders(self, ):
94 ashish 1721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1722 
    if mtype == TMessageType.EXCEPTION:
1723 
      x = TApplicationException()
1724 
      x.read(self._iprot)
1725 
      self._iprot.readMessageEnd()
1726 
      raise x
483 rajveer 1727 
    result = getAllOrders_result()
94 ashish 1728 
    result.read(self._iprot)
1729 
    self._iprot.readMessageEnd()
3431 rajveer 1730 
    if result.success is not None:
94 ashish 1731 
      return result.success
3431 rajveer 1732 
    if result.ex is not None:
94 ashish 1733 
      raise result.ex
483 rajveer 1734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1735 
 
4133 chandransh 1736 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1737 
    """
1738 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1739 
    Pass the status as null and the limit as 0 to ignore them.
1740 
 
1741 
    Parameters:
1742 
     - statuses
1743 
     - offset
1744 
     - limit
1745 
     - warehouse_id
1746 
    """
1747 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1748 
    return self.recv_getOrdersInBatch()
1749 
 
1750 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1751 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1752 
    args = getOrdersInBatch_args()
1753 
    args.statuses = statuses
1754 
    args.offset = offset
1755 
    args.limit = limit
1756 
    args.warehouse_id = warehouse_id
1757 
    args.write(self._oprot)
1758 
    self._oprot.writeMessageEnd()
1759 
    self._oprot.trans.flush()
1760 
 
1761 
  def recv_getOrdersInBatch(self, ):
1762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1763 
    if mtype == TMessageType.EXCEPTION:
1764 
      x = TApplicationException()
1765 
      x.read(self._iprot)
1766 
      self._iprot.readMessageEnd()
1767 
      raise x
1768 
    result = getOrdersInBatch_result()
1769 
    result.read(self._iprot)
1770 
    self._iprot.readMessageEnd()
1771 
    if result.success is not None:
1772 
      return result.success
1773 
    if result.ex is not None:
1774 
      raise result.ex
1775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1776 
 
1777 
  def getOrderCount(self, statuses, warehouseId):
1778 
    """
1779 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1780 
 
1781 
    Parameters:
1782 
     - statuses
1783 
     - warehouseId
1784 
    """
1785 
    self.send_getOrderCount(statuses, warehouseId)
1786 
    return self.recv_getOrderCount()
1787 
 
1788 
  def send_getOrderCount(self, statuses, warehouseId):
1789 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1790 
    args = getOrderCount_args()
1791 
    args.statuses = statuses
1792 
    args.warehouseId = warehouseId
1793 
    args.write(self._oprot)
1794 
    self._oprot.writeMessageEnd()
1795 
    self._oprot.trans.flush()
1796 
 
1797 
  def recv_getOrderCount(self, ):
1798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1799 
    if mtype == TMessageType.EXCEPTION:
1800 
      x = TApplicationException()
1801 
      x.read(self._iprot)
1802 
      self._iprot.readMessageEnd()
1803 
      raise x
1804 
    result = getOrderCount_result()
1805 
    result.read(self._iprot)
1806 
    self._iprot.readMessageEnd()
1807 
    if result.success is not None:
1808 
      return result.success
1809 
    if result.ex is not None:
1810 
      raise result.ex
1811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1812 
 
999 varun.gupt 1813 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1814 
    """
1132 chandransh 1815 
    Returns orders within a range of their billing dates
3431 rajveer 1816 
 
999 varun.gupt 1817 
    Parameters:
1818 
     - status
1819 
     - start_billing_date
1820 
     - end_billing_date
1821 
     - warehouse_id
1822 
    """
1823 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1824 
    return self.recv_getOrdersByBillingDate()
1825 
 
1826 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1827 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1828 
    args = getOrdersByBillingDate_args()
1829 
    args.status = status
1830 
    args.start_billing_date = start_billing_date
1831 
    args.end_billing_date = end_billing_date
1832 
    args.warehouse_id = warehouse_id
1833 
    args.write(self._oprot)
1834 
    self._oprot.writeMessageEnd()
1835 
    self._oprot.trans.flush()
1836 
 
1837 
  def recv_getOrdersByBillingDate(self, ):
1838 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1839 
    if mtype == TMessageType.EXCEPTION:
1840 
      x = TApplicationException()
1841 
      x.read(self._iprot)
1842 
      self._iprot.readMessageEnd()
1843 
      raise x
1844 
    result = getOrdersByBillingDate_result()
1845 
    result.read(self._iprot)
1846 
    self._iprot.readMessageEnd()
3431 rajveer 1847 
    if result.success is not None:
999 varun.gupt 1848 
      return result.success
3431 rajveer 1849 
    if result.ex is not None:
999 varun.gupt 1850 
      raise result.ex
1851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1852 
 
3451 chandransh 1853 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1854 
    """
1855 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1856 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1857 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1858 
 
3427 chandransh 1859 
    Parameters:
1860 
     - fromShippingDate
1861 
     - toShippingDate
1862 
     - providerId
1863 
     - warehouseId
3451 chandransh 1864 
     - cod
3427 chandransh 1865 
    """
3451 chandransh 1866 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1867 
    return self.recv_getOrdersByShippingDate()
1868 
 
3451 chandransh 1869 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1870 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1871 
    args = getOrdersByShippingDate_args()
1872 
    args.fromShippingDate = fromShippingDate
1873 
    args.toShippingDate = toShippingDate
1874 
    args.providerId = providerId
1875 
    args.warehouseId = warehouseId
3451 chandransh 1876 
    args.cod = cod
3427 chandransh 1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
1881 
  def recv_getOrdersByShippingDate(self, ):
1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
1888 
    result = getOrdersByShippingDate_result()
1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
3431 rajveer 1891 
    if result.success is not None:
3427 chandransh 1892 
      return result.success
3431 rajveer 1893 
    if result.ex is not None:
3427 chandransh 1894 
      raise result.ex
1895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1896 
 
1382 varun.gupt 1897 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1898 
    """
1899 
    Returns order ids for orders which can be returned
3431 rajveer 1900 
 
1382 varun.gupt 1901 
    Parameters:
1902 
     - customer_id
1903 
     - limit
1904 
    """
1905 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1906 
    return self.recv_getReturnableOrdersForCustomer()
1907 
 
1908 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1909 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1910 
    args = getReturnableOrdersForCustomer_args()
1911 
    args.customer_id = customer_id
1912 
    args.limit = limit
1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1917 
  def recv_getReturnableOrdersForCustomer(self, ):
1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1924 
    result = getReturnableOrdersForCustomer_result()
1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
3431 rajveer 1927 
    if result.success is not None:
1382 varun.gupt 1928 
      return result.success
3431 rajveer 1929 
    if result.ex is not None:
1382 varun.gupt 1930 
      raise result.ex
1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1932 
 
1933 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1934 
    """
1935 
    Returns order ids for orders which can be cancelled
3431 rajveer 1936 
 
1382 varun.gupt 1937 
    Parameters:
1938 
     - customer_id
1939 
     - limit
1940 
    """
1941 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1942 
    return self.recv_getCancellableOrdersForCustomer()
1943 
 
1944 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1945 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1946 
    args = getCancellableOrdersForCustomer_args()
1947 
    args.customer_id = customer_id
1948 
    args.limit = limit
1949 
    args.write(self._oprot)
1950 
    self._oprot.writeMessageEnd()
1951 
    self._oprot.trans.flush()
1952 
 
1953 
  def recv_getCancellableOrdersForCustomer(self, ):
1954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1955 
    if mtype == TMessageType.EXCEPTION:
1956 
      x = TApplicationException()
1957 
      x.read(self._iprot)
1958 
      self._iprot.readMessageEnd()
1959 
      raise x
1960 
    result = getCancellableOrdersForCustomer_result()
1961 
    result.read(self._iprot)
1962 
    self._iprot.readMessageEnd()
3431 rajveer 1963 
    if result.success is not None:
1382 varun.gupt 1964 
      return result.success
3431 rajveer 1965 
    if result.ex is not None:
1382 varun.gupt 1966 
      raise result.ex
1967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1968 
 
483 rajveer 1969 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1970 
    """
1971 
    Parameters:
483 rajveer 1972 
     - orderId
1973 
     - status
1974 
     - description
94 ashish 1975 
    """
483 rajveer 1976 
    self.send_changeOrderStatus(orderId, status, description)
1977 
    return self.recv_changeOrderStatus()
94 ashish 1978 
 
483 rajveer 1979 
  def send_changeOrderStatus(self, orderId, status, description):
1980 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1981 
    args = changeOrderStatus_args()
1982 
    args.orderId = orderId
1983 
    args.status = status
1984 
    args.description = description
94 ashish 1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
483 rajveer 1989 
  def recv_changeOrderStatus(self, ):
94 ashish 1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
483 rajveer 1996 
    result = changeOrderStatus_result()
94 ashish 1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
3431 rajveer 1999 
    if result.success is not None:
94 ashish 2000 
      return result.success
3431 rajveer 2001 
    if result.ex is not None:
94 ashish 2002 
      raise result.ex
483 rajveer 2003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2004 
 
1528 ankur.sing 2005 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2006 
    """
1528 ankur.sing 2007 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2008 
    only user who owns the transaction can view its order details.
3431 rajveer 2009 
 
94 ashish 2010 
    Parameters:
2011 
     - transactionId
1528 ankur.sing 2012 
     - customerId
94 ashish 2013 
    """
1528 ankur.sing 2014 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2015 
    return self.recv_getOrdersForTransaction()
94 ashish 2016 
 
1528 ankur.sing 2017 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2018 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2019 
    args = getOrdersForTransaction_args()
94 ashish 2020 
    args.transactionId = transactionId
1528 ankur.sing 2021 
    args.customerId = customerId
94 ashish 2022 
    args.write(self._oprot)
2023 
    self._oprot.writeMessageEnd()
2024 
    self._oprot.trans.flush()
2025 
 
483 rajveer 2026 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2028 
    if mtype == TMessageType.EXCEPTION:
2029 
      x = TApplicationException()
2030 
      x.read(self._iprot)
2031 
      self._iprot.readMessageEnd()
2032 
      raise x
483 rajveer 2033 
    result = getOrdersForTransaction_result()
94 ashish 2034 
    result.read(self._iprot)
2035 
    self._iprot.readMessageEnd()
3431 rajveer 2036 
    if result.success is not None:
94 ashish 2037 
      return result.success
3431 rajveer 2038 
    if result.ex is not None:
94 ashish 2039 
      raise result.ex
483 rajveer 2040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2041 
 
3014 chandransh 2042 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2043 
    """
3014 chandransh 2044 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2045 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2046 
 
94 ashish 2047 
    Parameters:
483 rajveer 2048 
     - customerId
2049 
     - from_date
2050 
     - to_date
3014 chandransh 2051 
     - statuses
94 ashish 2052 
    """
3014 chandransh 2053 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2054 
    return self.recv_getOrdersForCustomer()
94 ashish 2055 
 
3014 chandransh 2056 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2057 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2058 
    args = getOrdersForCustomer_args()
2059 
    args.customerId = customerId
2060 
    args.from_date = from_date
2061 
    args.to_date = to_date
3014 chandransh 2062 
    args.statuses = statuses
94 ashish 2063 
    args.write(self._oprot)
2064 
    self._oprot.writeMessageEnd()
2065 
    self._oprot.trans.flush()
2066 
 
483 rajveer 2067 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2069 
    if mtype == TMessageType.EXCEPTION:
2070 
      x = TApplicationException()
2071 
      x.read(self._iprot)
2072 
      self._iprot.readMessageEnd()
2073 
      raise x
483 rajveer 2074 
    result = getOrdersForCustomer_result()
94 ashish 2075 
    result.read(self._iprot)
2076 
    self._iprot.readMessageEnd()
3431 rajveer 2077 
    if result.success is not None:
94 ashish 2078 
      return result.success
3431 rajveer 2079 
    if result.ex is not None:
94 ashish 2080 
      raise result.ex
483 rajveer 2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2082 
 
483 rajveer 2083 
  def createOrder(self, order):
94 ashish 2084 
    """
2085 
    Parameters:
483 rajveer 2086 
     - order
94 ashish 2087 
    """
483 rajveer 2088 
    self.send_createOrder(order)
2089 
    return self.recv_createOrder()
94 ashish 2090 
 
483 rajveer 2091 
  def send_createOrder(self, order):
2092 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2093 
    args = createOrder_args()
2094 
    args.order = order
94 ashish 2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
483 rajveer 2099 
  def recv_createOrder(self, ):
94 ashish 2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
483 rajveer 2106 
    result = createOrder_result()
94 ashish 2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
3431 rajveer 2109 
    if result.success is not None:
94 ashish 2110 
      return result.success
3431 rajveer 2111 
    if result.ex is not None:
94 ashish 2112 
      raise result.ex
483 rajveer 2113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2114 
 
483 rajveer 2115 
  def getOrder(self, id):
94 ashish 2116 
    """
2117 
    Parameters:
483 rajveer 2118 
     - id
94 ashish 2119 
    """
483 rajveer 2120 
    self.send_getOrder(id)
2121 
    return self.recv_getOrder()
94 ashish 2122 
 
483 rajveer 2123 
  def send_getOrder(self, id):
2124 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2125 
    args = getOrder_args()
2126 
    args.id = id
94 ashish 2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
483 rajveer 2131 
  def recv_getOrder(self, ):
94 ashish 2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
483 rajveer 2138 
    result = getOrder_result()
94 ashish 2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
3431 rajveer 2141 
    if result.success is not None:
94 ashish 2142 
      return result.success
3431 rajveer 2143 
    if result.ex is not None:
94 ashish 2144 
      raise result.ex
483 rajveer 2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2146 
 
483 rajveer 2147 
  def getLineItemsForOrder(self, orderId):
94 ashish 2148 
    """
2149 
    Parameters:
483 rajveer 2150 
     - orderId
94 ashish 2151 
    """
483 rajveer 2152 
    self.send_getLineItemsForOrder(orderId)
2153 
    return self.recv_getLineItemsForOrder()
94 ashish 2154 
 
483 rajveer 2155 
  def send_getLineItemsForOrder(self, orderId):
2156 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2157 
    args = getLineItemsForOrder_args()
2158 
    args.orderId = orderId
94 ashish 2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
483 rajveer 2163 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
483 rajveer 2170 
    result = getLineItemsForOrder_result()
94 ashish 2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
3431 rajveer 2173 
    if result.success is not None:
94 ashish 2174 
      return result.success
3431 rajveer 2175 
    if result.ex is not None:
94 ashish 2176 
      raise result.ex
483 rajveer 2177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2178 
 
4999 phani.kuma 2179 
  def getOrderList(self, order_ids):
2180 
    """
2181 
    Parameters:
2182 
     - order_ids
2183 
    """
2184 
    self.send_getOrderList(order_ids)
2185 
    return self.recv_getOrderList()
2186 
 
2187 
  def send_getOrderList(self, order_ids):
2188 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2189 
    args = getOrderList_args()
2190 
    args.order_ids = order_ids
2191 
    args.write(self._oprot)
2192 
    self._oprot.writeMessageEnd()
2193 
    self._oprot.trans.flush()
2194 
 
2195 
  def recv_getOrderList(self, ):
2196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2197 
    if mtype == TMessageType.EXCEPTION:
2198 
      x = TApplicationException()
2199 
      x.read(self._iprot)
2200 
      self._iprot.readMessageEnd()
2201 
      raise x
2202 
    result = getOrderList_result()
2203 
    result.read(self._iprot)
2204 
    self._iprot.readMessageEnd()
2205 
    if result.success is not None:
2206 
      return result.success
2207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2208 
 
5386 phani.kuma 2209 
  def getOrderListForVendor(self, order_ids, vendorId):
2210 
    """
2211 
    Parameters:
2212 
     - order_ids
2213 
     - vendorId
2214 
    """
2215 
    self.send_getOrderListForVendor(order_ids, vendorId)
2216 
    return self.recv_getOrderListForVendor()
2217 
 
2218 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2219 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2220 
    args = getOrderListForVendor_args()
2221 
    args.order_ids = order_ids
2222 
    args.vendorId = vendorId
2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
2227 
  def recv_getOrderListForVendor(self, ):
2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
2234 
    result = getOrderListForVendor_result()
2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
2237 
    if result.success is not None:
2238 
      return result.success
2239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2240 
 
1528 ankur.sing 2241 
  def getOrderForCustomer(self, orderId, customerId):
2242 
    """
2243 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2244 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2245 
 
1528 ankur.sing 2246 
    Parameters:
2247 
     - orderId
2248 
     - customerId
2249 
    """
2250 
    self.send_getOrderForCustomer(orderId, customerId)
2251 
    return self.recv_getOrderForCustomer()
2252 
 
2253 
  def send_getOrderForCustomer(self, orderId, customerId):
2254 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2255 
    args = getOrderForCustomer_args()
2256 
    args.orderId = orderId
2257 
    args.customerId = customerId
2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
2262 
  def recv_getOrderForCustomer(self, ):
2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
2269 
    result = getOrderForCustomer_result()
2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
3431 rajveer 2272 
    if result.success is not None:
1528 ankur.sing 2273 
      return result.success
3431 rajveer 2274 
    if result.ex is not None:
1528 ankur.sing 2275 
      raise result.ex
2276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2277 
 
4444 rajveer 2278 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2279 
    """
2280 
    Parameters:
4394 rajveer 2281 
     - type
4444 rajveer 2282 
     - warehouseId
4394 rajveer 2283 
     - status
2284 
     - timestamp
3064 chandransh 2285 
    """
4444 rajveer 2286 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2287 
    return self.recv_getAlerts()
2288 
 
4444 rajveer 2289 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2290 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2291 
    args = getAlerts_args()
4394 rajveer 2292 
    args.type = type
4444 rajveer 2293 
    args.warehouseId = warehouseId
4394 rajveer 2294 
    args.status = status
2295 
    args.timestamp = timestamp
3064 chandransh 2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_getAlerts(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = getAlerts_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
3431 rajveer 2310 
    if result.success is not None:
3064 chandransh 2311 
      return result.success
2312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2313 
 
4444 rajveer 2314 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2315 
    """
2316 
    Parameters:
2317 
     - type
4444 rajveer 2318 
     - warehouseId
4394 rajveer 2319 
     - description
3064 chandransh 2320 
    """
4444 rajveer 2321 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2322 
    self.recv_addAlert()
3064 chandransh 2323 
 
4444 rajveer 2324 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2325 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2326 
    args = addAlert_args()
3064 chandransh 2327 
    args.type = type
4444 rajveer 2328 
    args.warehouseId = warehouseId
4394 rajveer 2329 
    args.description = description
3064 chandransh 2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
4394 rajveer 2334 
  def recv_addAlert(self, ):
3064 chandransh 2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
4394 rajveer 2341 
    result = addAlert_result()
3064 chandransh 2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
2344 
    return
2345 
 
4444 rajveer 2346 
  def markAlertsAsSeen(self, warehouseId):
2347 
    """
2348 
    Parameters:
2349 
     - warehouseId
2350 
    """
2351 
    self.send_markAlertsAsSeen(warehouseId)
2352 
    self.recv_markAlertsAsSeen()
2353 
 
2354 
  def send_markAlertsAsSeen(self, warehouseId):
2355 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2356 
    args = markAlertsAsSeen_args()
2357 
    args.warehouseId = warehouseId
2358 
    args.write(self._oprot)
2359 
    self._oprot.writeMessageEnd()
2360 
    self._oprot.trans.flush()
2361 
 
2362 
  def recv_markAlertsAsSeen(self, ):
2363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2364 
    if mtype == TMessageType.EXCEPTION:
2365 
      x = TApplicationException()
2366 
      x.read(self._iprot)
2367 
      self._iprot.readMessageEnd()
2368 
      raise x
2369 
    result = markAlertsAsSeen_result()
2370 
    result.read(self._iprot)
2371 
    self._iprot.readMessageEnd()
2372 
    return
2373 
 
3064 chandransh 2374 
  def getValidOrderCount(self, ):
2375 
    """
2376 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2377 
    """
2378 
    self.send_getValidOrderCount()
2379 
    return self.recv_getValidOrderCount()
2380 
 
2381 
  def send_getValidOrderCount(self, ):
2382 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2383 
    args = getValidOrderCount_args()
2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
2388 
  def recv_getValidOrderCount(self, ):
2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
2395 
    result = getValidOrderCount_result()
2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
3431 rajveer 2398 
    if result.success is not None:
3064 chandransh 2399 
      return result.success
2400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2401 
 
2402 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2403 
    """
2404 
    Returns the number of distinct customers who have done successful transactions
2405 
    """
2406 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2407 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2408 
 
2409 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2410 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2411 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
2416 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
2423 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
3431 rajveer 2426 
    if result.success is not None:
3064 chandransh 2427 
      return result.success
2428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2429 
 
2430 
  def getValidOrdersAmountRange(self, ):
2431 
    """
2432 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2433 
    List contains two values, first minimum amount and second maximum amount.
2434 
    """
2435 
    self.send_getValidOrdersAmountRange()
2436 
    return self.recv_getValidOrdersAmountRange()
2437 
 
2438 
  def send_getValidOrdersAmountRange(self, ):
2439 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2440 
    args = getValidOrdersAmountRange_args()
2441 
    args.write(self._oprot)
2442 
    self._oprot.writeMessageEnd()
2443 
    self._oprot.trans.flush()
2444 
 
2445 
  def recv_getValidOrdersAmountRange(self, ):
2446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2447 
    if mtype == TMessageType.EXCEPTION:
2448 
      x = TApplicationException()
2449 
      x.read(self._iprot)
2450 
      self._iprot.readMessageEnd()
2451 
      raise x
2452 
    result = getValidOrdersAmountRange_result()
2453 
    result.read(self._iprot)
2454 
    self._iprot.readMessageEnd()
3431 rajveer 2455 
    if result.success is not None:
3064 chandransh 2456 
      return result.success
2457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2458 
 
5874 rajveer 2459 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2460 
    """
2461 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2462 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2463 
 
3064 chandransh 2464 
    Parameters:
2465 
     - limit
5874 rajveer 2466 
     - onlyStore
3064 chandransh 2467 
    """
5874 rajveer 2468 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2469 
    return self.recv_getValidOrders()
2470 
 
5874 rajveer 2471 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2472 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2473 
    args = getValidOrders_args()
2474 
    args.limit = limit
5874 rajveer 2475 
    args.onlyStore = onlyStore
3064 chandransh 2476 
    args.write(self._oprot)
2477 
    self._oprot.writeMessageEnd()
2478 
    self._oprot.trans.flush()
2479 
 
2480 
  def recv_getValidOrders(self, ):
2481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2482 
    if mtype == TMessageType.EXCEPTION:
2483 
      x = TApplicationException()
2484 
      x.read(self._iprot)
2485 
      self._iprot.readMessageEnd()
2486 
      raise x
2487 
    result = getValidOrders_result()
2488 
    result.read(self._iprot)
2489 
    self._iprot.readMessageEnd()
3431 rajveer 2490 
    if result.success is not None:
3064 chandransh 2491 
      return result.success
2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2493 
 
1220 chandransh 2494 
  def batchOrders(self, warehouseId):
2495 
    """
2496 
    Create a batch of all the pending orders for the given warehouse.
2497 
    The returned list is orderd by created_timestamp.
2498 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2499 
 
1220 chandransh 2500 
    Parameters:
2501 
     - warehouseId
2502 
    """
2503 
    self.send_batchOrders(warehouseId)
2504 
    return self.recv_batchOrders()
2505 
 
2506 
  def send_batchOrders(self, warehouseId):
2507 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2508 
    args = batchOrders_args()
2509 
    args.warehouseId = warehouseId
2510 
    args.write(self._oprot)
2511 
    self._oprot.writeMessageEnd()
2512 
    self._oprot.trans.flush()
2513 
 
2514 
  def recv_batchOrders(self, ):
2515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2516 
    if mtype == TMessageType.EXCEPTION:
2517 
      x = TApplicationException()
2518 
      x.read(self._iprot)
2519 
      self._iprot.readMessageEnd()
2520 
      raise x
2521 
    result = batchOrders_result()
2522 
    result.read(self._iprot)
2523 
    self._iprot.readMessageEnd()
3431 rajveer 2524 
    if result.success is not None:
1220 chandransh 2525 
      return result.success
3431 rajveer 2526 
    if result.ex is not None:
1220 chandransh 2527 
      raise result.ex
2528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2529 
 
1208 chandransh 2530 
  def markOrderAsOutOfStock(self, orderId):
2531 
    """
2532 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2533 
 
1208 chandransh 2534 
    Parameters:
2535 
     - orderId
2536 
    """
2537 
    self.send_markOrderAsOutOfStock(orderId)
2538 
    return self.recv_markOrderAsOutOfStock()
2539 
 
2540 
  def send_markOrderAsOutOfStock(self, orderId):
2541 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2542 
    args = markOrderAsOutOfStock_args()
2543 
    args.orderId = orderId
2544 
    args.write(self._oprot)
2545 
    self._oprot.writeMessageEnd()
2546 
    self._oprot.trans.flush()
2547 
 
2548 
  def recv_markOrderAsOutOfStock(self, ):
2549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2550 
    if mtype == TMessageType.EXCEPTION:
2551 
      x = TApplicationException()
2552 
      x.read(self._iprot)
2553 
      self._iprot.readMessageEnd()
2554 
      raise x
2555 
    result = markOrderAsOutOfStock_result()
2556 
    result.read(self._iprot)
2557 
    self._iprot.readMessageEnd()
3431 rajveer 2558 
    if result.success is not None:
1208 chandransh 2559 
      return result.success
3431 rajveer 2560 
    if result.ex is not None:
1208 chandransh 2561 
      raise result.ex
2562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2563 
 
3064 chandransh 2564 
  def verifyOrder(self, orderId):
759 chandransh 2565 
    """
3064 chandransh 2566 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2567 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2568 
    used for all other orders as well.
2569 
    Throws an exception if no such order exists.
3431 rajveer 2570 
 
759 chandransh 2571 
    Parameters:
3064 chandransh 2572 
     - orderId
759 chandransh 2573 
    """
3064 chandransh 2574 
    self.send_verifyOrder(orderId)
2575 
    return self.recv_verifyOrder()
759 chandransh 2576 
 
3064 chandransh 2577 
  def send_verifyOrder(self, orderId):
2578 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2579 
    args = verifyOrder_args()
2580 
    args.orderId = orderId
759 chandransh 2581 
    args.write(self._oprot)
2582 
    self._oprot.writeMessageEnd()
2583 
    self._oprot.trans.flush()
2584 
 
3064 chandransh 2585 
  def recv_verifyOrder(self, ):
759 chandransh 2586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2587 
    if mtype == TMessageType.EXCEPTION:
2588 
      x = TApplicationException()
2589 
      x.read(self._iprot)
2590 
      self._iprot.readMessageEnd()
2591 
      raise x
3064 chandransh 2592 
    result = verifyOrder_result()
759 chandransh 2593 
    result.read(self._iprot)
2594 
    self._iprot.readMessageEnd()
3431 rajveer 2595 
    if result.success is not None:
759 chandransh 2596 
      return result.success
3431 rajveer 2597 
    if result.ex is not None:
759 chandransh 2598 
      raise result.ex
3064 chandransh 2599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2600 
 
3064 chandransh 2601 
  def acceptOrder(self, orderId):
1113 chandransh 2602 
    """
3064 chandransh 2603 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2604 
    given order is not a COD order, it also captures the payment if the same has
2605 
    not been captured.
2606 
    Throws an exception if no such order exists.
3431 rajveer 2607 
 
1113 chandransh 2608 
    Parameters:
3064 chandransh 2609 
     - orderId
1113 chandransh 2610 
    """
3064 chandransh 2611 
    self.send_acceptOrder(orderId)
2612 
    return self.recv_acceptOrder()
1113 chandransh 2613 
 
3064 chandransh 2614 
  def send_acceptOrder(self, orderId):
2615 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2616 
    args = acceptOrder_args()
2617 
    args.orderId = orderId
1113 chandransh 2618 
    args.write(self._oprot)
2619 
    self._oprot.writeMessageEnd()
2620 
    self._oprot.trans.flush()
2621 
 
3064 chandransh 2622 
  def recv_acceptOrder(self, ):
1113 chandransh 2623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2624 
    if mtype == TMessageType.EXCEPTION:
2625 
      x = TApplicationException()
2626 
      x.read(self._iprot)
2627 
      self._iprot.readMessageEnd()
2628 
      raise x
3064 chandransh 2629 
    result = acceptOrder_result()
1113 chandransh 2630 
    result.read(self._iprot)
2631 
    self._iprot.readMessageEnd()
3431 rajveer 2632 
    if result.success is not None:
1113 chandransh 2633 
      return result.success
3431 rajveer 2634 
    if result.ex is not None:
1113 chandransh 2635 
      raise result.ex
3064 chandransh 2636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2637 
 
5110 mandeep.dh 2638 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2639 
    """
3064 chandransh 2640 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2641 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2642 
    the IMEI no. if a -1 is supplied.
2643 
    Also, it generates an invoice number for the order, marks the order as
2644 
    BILLED and sets the billing timestamp.
2645 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2646 
 
1135 chandransh 2647 
    Parameters:
3064 chandransh 2648 
     - orderId
2649 
     - invoice_number
4658 mandeep.dh 2650 
     - serialNumber
4283 anupam.sin 2651 
     - itemNumber
3064 chandransh 2652 
     - billed_by
4264 rajveer 2653 
     - jacketNumber
4283 anupam.sin 2654 
     - billingType
5110 mandeep.dh 2655 
     - fulfilmentWarehouseId
4763 rajveer 2656 
     - authorize
1135 chandransh 2657 
    """
5110 mandeep.dh 2658 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2659 
    return self.recv_addBillingDetails()
1135 chandransh 2660 
 
5110 mandeep.dh 2661 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2662 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2663 
    args = addBillingDetails_args()
2664 
    args.orderId = orderId
2665 
    args.invoice_number = invoice_number
4658 mandeep.dh 2666 
    args.serialNumber = serialNumber
4283 anupam.sin 2667 
    args.itemNumber = itemNumber
3064 chandransh 2668 
    args.billed_by = billed_by
4264 rajveer 2669 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2670 
    args.billingType = billingType
5110 mandeep.dh 2671 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2672 
    args.authorize = authorize
1135 chandransh 2673 
    args.write(self._oprot)
2674 
    self._oprot.writeMessageEnd()
2675 
    self._oprot.trans.flush()
2676 
 
3064 chandransh 2677 
  def recv_addBillingDetails(self, ):
1135 chandransh 2678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2679 
    if mtype == TMessageType.EXCEPTION:
2680 
      x = TApplicationException()
2681 
      x.read(self._iprot)
2682 
      self._iprot.readMessageEnd()
2683 
      raise x
3064 chandransh 2684 
    result = addBillingDetails_result()
1135 chandransh 2685 
    result.read(self._iprot)
2686 
    self._iprot.readMessageEnd()
3431 rajveer 2687 
    if result.success is not None:
3064 chandransh 2688 
      return result.success
3431 rajveer 2689 
    if result.ex is not None:
1135 chandransh 2690 
      raise result.ex
3064 chandransh 2691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2692 
 
6756 amar.kumar 2693 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2694 
    """
2695 
    Add the invoice number to the order.
2696 
 
2697 
    Parameters:
2698 
     - orderId
2699 
     - invoiceNumber
4763 rajveer 2700 
     - color
6756 amar.kumar 2701 
     - serialNumber
2702 
     - itemNumber
4579 rajveer 2703 
    """
6756 amar.kumar 2704 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2705 
    self.recv_addInvoiceNumber()
2706 
 
6756 amar.kumar 2707 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2708 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2709 
    args = addInvoiceNumber_args()
2710 
    args.orderId = orderId
2711 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2712 
    args.color = color
6756 amar.kumar 2713 
    args.serialNumber = serialNumber
2714 
    args.itemNumber = itemNumber
4579 rajveer 2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
2719 
  def recv_addInvoiceNumber(self, ):
2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
2726 
    result = addInvoiceNumber_result()
2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
2729 
    if result.ex is not None:
2730 
      raise result.ex
2731 
    return
2732 
 
4910 phani.kuma 2733 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2734 
    """
3064 chandransh 2735 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2736 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2737 
 
1408 ankur.sing 2738 
    Parameters:
3064 chandransh 2739 
     - warehouseId
1408 ankur.sing 2740 
     - providerId
3064 chandransh 2741 
     - cod
4910 phani.kuma 2742 
     - orderIds
1408 ankur.sing 2743 
    """
4910 phani.kuma 2744 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2745 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2746 
 
4910 phani.kuma 2747 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2748 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2749 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2750 
    args.warehouseId = warehouseId
1408 ankur.sing 2751 
    args.providerId = providerId
3064 chandransh 2752 
    args.cod = cod
4910 phani.kuma 2753 
    args.orderIds = orderIds
1408 ankur.sing 2754 
    args.write(self._oprot)
2755 
    self._oprot.writeMessageEnd()
2756 
    self._oprot.trans.flush()
2757 
 
4910 phani.kuma 2758 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2760 
    if mtype == TMessageType.EXCEPTION:
2761 
      x = TApplicationException()
2762 
      x.read(self._iprot)
2763 
      self._iprot.readMessageEnd()
2764 
      raise x
4910 phani.kuma 2765 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2766 
    result.read(self._iprot)
2767 
    self._iprot.readMessageEnd()
3431 rajveer 2768 
    if result.success is not None:
1408 ankur.sing 2769 
      return result.success
3431 rajveer 2770 
    if result.ex is not None:
3064 chandransh 2771 
      raise result.ex
4910 phani.kuma 2772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2773 
 
5713 rajveer 2774 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2775 
    """
2776 
    Parameters:
2777 
     - providerId
2778 
     - orderIds
5713 rajveer 2779 
     - awbs
5676 rajveer 2780 
    """
5713 rajveer 2781 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2782 
    return self.recv_markOrdersAsReturnedFromStore()
2783 
 
5713 rajveer 2784 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2785 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2786 
    args = markOrdersAsReturnedFromStore_args()
2787 
    args.providerId = providerId
2788 
    args.orderIds = orderIds
5713 rajveer 2789 
    args.awbs = awbs
5676 rajveer 2790 
    args.write(self._oprot)
2791 
    self._oprot.writeMessageEnd()
2792 
    self._oprot.trans.flush()
2793 
 
2794 
  def recv_markOrdersAsReturnedFromStore(self, ):
2795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2796 
    if mtype == TMessageType.EXCEPTION:
2797 
      x = TApplicationException()
2798 
      x.read(self._iprot)
2799 
      self._iprot.readMessageEnd()
2800 
      raise x
2801 
    result = markOrdersAsReturnedFromStore_result()
2802 
    result.read(self._iprot)
2803 
    self._iprot.readMessageEnd()
2804 
    if result.success is not None:
2805 
      return result.success
2806 
    if result.ex is not None:
2807 
      raise result.ex
2808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2809 
 
4910 phani.kuma 2810 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2811 
    """
4910 phani.kuma 2812 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2813 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2814 
 
2815 
    Parameters:
2816 
     - providerId
4910 phani.kuma 2817 
     - pickupDetails
4410 rajveer 2818 
    """
4910 phani.kuma 2819 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2820 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2821 
 
4910 phani.kuma 2822 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2823 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2824 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2825 
    args.providerId = providerId
4910 phani.kuma 2826 
    args.pickupDetails = pickupDetails
4410 rajveer 2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
4910 phani.kuma 2831 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
4910 phani.kuma 2838 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
2841 
    if result.ex is not None:
2842 
      raise result.ex
4910 phani.kuma 2843 
    return
4410 rajveer 2844 
 
4910 phani.kuma 2845 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2846 
    """
3064 chandransh 2847 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2848 
 
94 ashish 2849 
    Parameters:
3064 chandransh 2850 
     - providerId
304 ashish 2851 
    """
4910 phani.kuma 2852 
    self.send_getOrdersNotPickedUp(providerId)
2853 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2854 
 
4910 phani.kuma 2855 
  def send_getOrdersNotPickedUp(self, providerId):
2856 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2857 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2858 
    args.providerId = providerId
304 ashish 2859 
    args.write(self._oprot)
2860 
    self._oprot.writeMessageEnd()
2861 
    self._oprot.trans.flush()
2862 
 
4910 phani.kuma 2863 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2865 
    if mtype == TMessageType.EXCEPTION:
2866 
      x = TApplicationException()
2867 
      x.read(self._iprot)
2868 
      self._iprot.readMessageEnd()
2869 
      raise x
4910 phani.kuma 2870 
    result = getOrdersNotPickedUp_result()
304 ashish 2871 
    result.read(self._iprot)
2872 
    self._iprot.readMessageEnd()
3431 rajveer 2873 
    if result.success is not None:
304 ashish 2874 
      return result.success
4910 phani.kuma 2875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2876 
 
3064 chandransh 2877 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2878 
    """
3064 chandransh 2879 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2880 
    the name of the receiver.
2881 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2882 
 
304 ashish 2883 
    Parameters:
3064 chandransh 2884 
     - providerId
2885 
     - deliveredOrders
304 ashish 2886 
    """
3064 chandransh 2887 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2888 
    self.recv_markOrdersAsDelivered()
304 ashish 2889 
 
3064 chandransh 2890 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2891 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2892 
    args = markOrdersAsDelivered_args()
2893 
    args.providerId = providerId
2894 
    args.deliveredOrders = deliveredOrders
304 ashish 2895 
    args.write(self._oprot)
2896 
    self._oprot.writeMessageEnd()
2897 
    self._oprot.trans.flush()
2898 
 
3064 chandransh 2899 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2901 
    if mtype == TMessageType.EXCEPTION:
2902 
      x = TApplicationException()
2903 
      x.read(self._iprot)
2904 
      self._iprot.readMessageEnd()
2905 
      raise x
3064 chandransh 2906 
    result = markOrdersAsDelivered_result()
304 ashish 2907 
    result.read(self._iprot)
2908 
    self._iprot.readMessageEnd()
3431 rajveer 2909 
    if result.ex is not None:
3064 chandransh 2910 
      raise result.ex
304 ashish 2911 
    return
2912 
 
4910 phani.kuma 2913 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2914 
    """
4910 phani.kuma 2915 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2916 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2917 
 
3064 chandransh 2918 
    Parameters:
2919 
     - providerId
2920 
     - returnedOrders
1596 ankur.sing 2921 
    """
4910 phani.kuma 2922 
    self.send_markAsRTOrders(providerId, returnedOrders)
2923 
    self.recv_markAsRTOrders()
304 ashish 2924 
 
4910 phani.kuma 2925 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2926 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2927 
    args = markAsRTOrders_args()
3064 chandransh 2928 
    args.providerId = providerId
2929 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2930 
    args.write(self._oprot)
2931 
    self._oprot.writeMessageEnd()
2932 
    self._oprot.trans.flush()
2933 
 
4910 phani.kuma 2934 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2936 
    if mtype == TMessageType.EXCEPTION:
2937 
      x = TApplicationException()
2938 
      x.read(self._iprot)
2939 
      self._iprot.readMessageEnd()
2940 
      raise x
4910 phani.kuma 2941 
    result = markAsRTOrders_result()
1596 ankur.sing 2942 
    result.read(self._iprot)
2943 
    self._iprot.readMessageEnd()
3431 rajveer 2944 
    if result.ex is not None:
3064 chandransh 2945 
      raise result.ex
2946 
    return
1596 ankur.sing 2947 
 
4910 phani.kuma 2948 
  def getRTOrders(self, providerId):
2949 
    """
2950 
    Returns a list of orders that were returned by courier.
2951 
 
2952 
    Parameters:
2953 
     - providerId
2954 
    """
2955 
    self.send_getRTOrders(providerId)
2956 
    return self.recv_getRTOrders()
2957 
 
2958 
  def send_getRTOrders(self, providerId):
2959 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2960 
    args = getRTOrders_args()
2961 
    args.providerId = providerId
2962 
    args.write(self._oprot)
2963 
    self._oprot.writeMessageEnd()
2964 
    self._oprot.trans.flush()
2965 
 
2966 
  def recv_getRTOrders(self, ):
2967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2968 
    if mtype == TMessageType.EXCEPTION:
2969 
      x = TApplicationException()
2970 
      x.read(self._iprot)
2971 
      self._iprot.readMessageEnd()
2972 
      raise x
2973 
    result = getRTOrders_result()
2974 
    result.read(self._iprot)
2975 
    self._iprot.readMessageEnd()
2976 
    if result.success is not None:
2977 
      return result.success
2978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2979 
 
3064 chandransh 2980 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2981 
    """
3064 chandransh 2982 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2983 
 
3064 chandransh 2984 
    Parameters:
2985 
     - providerId
2986 
     - undeliveredOrders
1627 ankur.sing 2987 
    """
3064 chandransh 2988 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2989 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2990 
 
3064 chandransh 2991 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2992 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2993 
    args = updateNonDeliveryReason_args()
2994 
    args.providerId = providerId
2995 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2996 
    args.write(self._oprot)
2997 
    self._oprot.writeMessageEnd()
2998 
    self._oprot.trans.flush()
2999 
 
3064 chandransh 3000 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3002 
    if mtype == TMessageType.EXCEPTION:
3003 
      x = TApplicationException()
3004 
      x.read(self._iprot)
3005 
      self._iprot.readMessageEnd()
3006 
      raise x
3064 chandransh 3007 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3008 
    result.read(self._iprot)
3009 
    self._iprot.readMessageEnd()
4910 phani.kuma 3010 
    if result.ex is not None:
3011 
      raise result.ex
3012 
    return
3013 
 
3014 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3015 
    """
3016 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3017 
 
3018 
    Parameters:
3019 
     - providerId
3020 
    """
3021 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3022 
    return self.recv_getNonDeliveredOrdersbyCourier()
3023 
 
3024 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3025 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3026 
    args = getNonDeliveredOrdersbyCourier_args()
3027 
    args.providerId = providerId
3028 
    args.write(self._oprot)
3029 
    self._oprot.writeMessageEnd()
3030 
    self._oprot.trans.flush()
3031 
 
3032 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3034 
    if mtype == TMessageType.EXCEPTION:
3035 
      x = TApplicationException()
3036 
      x.read(self._iprot)
3037 
      self._iprot.readMessageEnd()
3038 
      raise x
3039 
    result = getNonDeliveredOrdersbyCourier_result()
3040 
    result.read(self._iprot)
3041 
    self._iprot.readMessageEnd()
4581 phani.kuma 3042 
    if result.success is not None:
3043 
      return result.success
4910 phani.kuma 3044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3045 
 
3046 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3047 
    """
3048 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3049 
 
3050 
    Parameters:
3051 
     - providerId
3052 
     - local_connected_orders
3053 
    """
3054 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3055 
    self.recv_markOrdersAsLocalConnected()
3056 
 
3057 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3058 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3059 
    args = markOrdersAsLocalConnected_args()
3060 
    args.providerId = providerId
3061 
    args.local_connected_orders = local_connected_orders
3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
3066 
  def recv_markOrdersAsLocalConnected(self, ):
3067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3068 
    if mtype == TMessageType.EXCEPTION:
3069 
      x = TApplicationException()
3070 
      x.read(self._iprot)
3071 
      self._iprot.readMessageEnd()
3072 
      raise x
3073 
    result = markOrdersAsLocalConnected_result()
3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
3431 rajveer 3076 
    if result.ex is not None:
3064 chandransh 3077 
      raise result.ex
4910 phani.kuma 3078 
    return
1627 ankur.sing 3079 
 
4910 phani.kuma 3080 
  def getOrdersNotLocalConnected(self, providerId):
3081 
    """
3082 
    Returns a list of orders that were picked up or shipped but pending local connection.
3083 
 
3084 
    Parameters:
3085 
     - providerId
3086 
    """
3087 
    self.send_getOrdersNotLocalConnected(providerId)
3088 
    return self.recv_getOrdersNotLocalConnected()
3089 
 
3090 
  def send_getOrdersNotLocalConnected(self, providerId):
3091 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3092 
    args = getOrdersNotLocalConnected_args()
3093 
    args.providerId = providerId
3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
3097 
 
3098 
  def recv_getOrdersNotLocalConnected(self, ):
3099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3100 
    if mtype == TMessageType.EXCEPTION:
3101 
      x = TApplicationException()
3102 
      x.read(self._iprot)
3103 
      self._iprot.readMessageEnd()
3104 
      raise x
3105 
    result = getOrdersNotLocalConnected_result()
3106 
    result.read(self._iprot)
3107 
    self._iprot.readMessageEnd()
3108 
    if result.success is not None:
3109 
      return result.success
3110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3111 
 
3112 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3113 
    """
3114 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3115 
 
3116 
    Parameters:
3117 
     - providerId
3118 
     - destination_city_reached_orders
3119 
    """
3120 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3121 
    self.recv_markOrdersAsDestinationCityReached()
3122 
 
3123 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3124 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3125 
    args = markOrdersAsDestinationCityReached_args()
3126 
    args.providerId = providerId
3127 
    args.destination_city_reached_orders = destination_city_reached_orders
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_markOrdersAsDestinationCityReached(self, ):
3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3139 
    result = markOrdersAsDestinationCityReached_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3142 
    if result.ex is not None:
3143 
      raise result.ex
3144 
    return
3145 
 
3146 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3147 
    """
3148 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3149 
 
3150 
    Parameters:
3151 
     - providerId
3152 
     - first_atdl_orders
3153 
    """
3154 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3155 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3156 
 
3157 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3158 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3159 
    args = markOrdersAsFirstDeliveryAttempted_args()
3160 
    args.providerId = providerId
3161 
    args.first_atdl_orders = first_atdl_orders
3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = markOrdersAsFirstDeliveryAttempted_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3176 
    if result.ex is not None:
3177 
      raise result.ex
3178 
    return
3179 
 
3064 chandransh 3180 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3181 
    """
3064 chandransh 3182 
    Returns the list of orders whose delivery time has passed but have not been
3183 
    delivered yet for the given provider and warehouse. To get a complete list of
3184 
    undelivered orders, pass them as -1.
3185 
    Returns an empty list if no such orders exist.
3431 rajveer 3186 
 
1886 ankur.sing 3187 
    Parameters:
3064 chandransh 3188 
     - providerId
3189 
     - warehouseId
1886 ankur.sing 3190 
    """
3064 chandransh 3191 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3192 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3193 
 
3064 chandransh 3194 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3195 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3196 
    args = getUndeliveredOrders_args()
3197 
    args.providerId = providerId
3198 
    args.warehouseId = warehouseId
1886 ankur.sing 3199 
    args.write(self._oprot)
3200 
    self._oprot.writeMessageEnd()
3201 
    self._oprot.trans.flush()
3202 
 
3064 chandransh 3203 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3205 
    if mtype == TMessageType.EXCEPTION:
3206 
      x = TApplicationException()
3207 
      x.read(self._iprot)
3208 
      self._iprot.readMessageEnd()
3209 
      raise x
3064 chandransh 3210 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3211 
    result.read(self._iprot)
3212 
    self._iprot.readMessageEnd()
3431 rajveer 3213 
    if result.success is not None:
1886 ankur.sing 3214 
      return result.success
3064 chandransh 3215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3216 
 
4783 phani.kuma 3217 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3218 
    """
3219 
    Returns the list of orders whose expected delivery date has passed but have not been
3220 
    delivered yet.
3221 
    Returns an empty list if no such orders exist.
3222 
    """
3223 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3224 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3225 
 
3226 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3227 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3228 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3229 
    args.write(self._oprot)
3230 
    self._oprot.writeMessageEnd()
3231 
    self._oprot.trans.flush()
3232 
 
3233 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3235 
    if mtype == TMessageType.EXCEPTION:
3236 
      x = TApplicationException()
3237 
      x.read(self._iprot)
3238 
      self._iprot.readMessageEnd()
3239 
      raise x
3240 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3241 
    result.read(self._iprot)
3242 
    self._iprot.readMessageEnd()
3243 
    if result.success is not None:
3244 
      return result.success
3245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3246 
 
2536 chandransh 3247 
  def toggleDOAFlag(self, orderId):
3248 
    """
3249 
    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.
3250 
    Returns the final flag status.
3251 
    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 3252 
 
2536 chandransh 3253 
    Parameters:
3254 
     - orderId
3255 
    """
3256 
    self.send_toggleDOAFlag(orderId)
3257 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3258 
 
2536 chandransh 3259 
  def send_toggleDOAFlag(self, orderId):
3260 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3261 
    args = toggleDOAFlag_args()
3262 
    args.orderId = orderId
3263 
    args.write(self._oprot)
3264 
    self._oprot.writeMessageEnd()
3265 
    self._oprot.trans.flush()
3266 
 
3267 
  def recv_toggleDOAFlag(self, ):
3268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3269 
    if mtype == TMessageType.EXCEPTION:
3270 
      x = TApplicationException()
3271 
      x.read(self._iprot)
3272 
      self._iprot.readMessageEnd()
3273 
      raise x
3274 
    result = toggleDOAFlag_result()
3275 
    result.read(self._iprot)
3276 
    self._iprot.readMessageEnd()
3431 rajveer 3277 
    if result.success is not None:
2536 chandransh 3278 
      return result.success
3431 rajveer 3279 
    if result.ex is not None:
2536 chandransh 3280 
      raise result.ex
3281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3282 
 
4712 rajveer 3283 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3284 
    """
3285 
    Parameters:
3286 
     - orderId
3287 
     - deliveryTimestamp
3288 
     - receiver
3289 
    """
3290 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3291 
    self.recv_markOrderAsDelivered()
3292 
 
3293 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3294 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3295 
    args = markOrderAsDelivered_args()
3296 
    args.orderId = orderId
3297 
    args.deliveryTimestamp = deliveryTimestamp
3298 
    args.receiver = receiver
3299 
    args.write(self._oprot)
3300 
    self._oprot.writeMessageEnd()
3301 
    self._oprot.trans.flush()
3302 
 
3303 
  def recv_markOrderAsDelivered(self, ):
3304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3305 
    if mtype == TMessageType.EXCEPTION:
3306 
      x = TApplicationException()
3307 
      x.read(self._iprot)
3308 
      self._iprot.readMessageEnd()
3309 
      raise x
3310 
    result = markOrderAsDelivered_result()
3311 
    result.read(self._iprot)
3312 
    self._iprot.readMessageEnd()
3313 
    if result.ex is not None:
3314 
      raise result.ex
3315 
    return
3316 
 
5553 rajveer 3317 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3318 
    """
3319 
    Parameters:
3320 
     - orderId
3321 
     - deliveryTimestamp
3322 
    """
3323 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3324 
    self.recv_markOrderAsReceivedAtStore()
3325 
 
3326 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3327 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3328 
    args = markOrderAsReceivedAtStore_args()
3329 
    args.orderId = orderId
3330 
    args.deliveryTimestamp = deliveryTimestamp
3331 
    args.write(self._oprot)
3332 
    self._oprot.writeMessageEnd()
3333 
    self._oprot.trans.flush()
3334 
 
3335 
  def recv_markOrderAsReceivedAtStore(self, ):
3336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3337 
    if mtype == TMessageType.EXCEPTION:
3338 
      x = TApplicationException()
3339 
      x.read(self._iprot)
3340 
      self._iprot.readMessageEnd()
3341 
      raise x
3342 
    result = markOrderAsReceivedAtStore_result()
3343 
    result.read(self._iprot)
3344 
    self._iprot.readMessageEnd()
3345 
    if result.ex is not None:
3346 
      raise result.ex
3347 
    return
3348 
 
4454 rajveer 3349 
  def markOrderDoaRequestReceived(self, orderId):
3350 
    """
3351 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3352 
 
3353 
    Parameters:
3354 
     - orderId
3355 
    """
3356 
    self.send_markOrderDoaRequestReceived(orderId)
3357 
    return self.recv_markOrderDoaRequestReceived()
3358 
 
3359 
  def send_markOrderDoaRequestReceived(self, orderId):
3360 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3361 
    args = markOrderDoaRequestReceived_args()
3362 
    args.orderId = orderId
3363 
    args.write(self._oprot)
3364 
    self._oprot.writeMessageEnd()
3365 
    self._oprot.trans.flush()
3366 
 
3367 
  def recv_markOrderDoaRequestReceived(self, ):
3368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3369 
    if mtype == TMessageType.EXCEPTION:
3370 
      x = TApplicationException()
3371 
      x.read(self._iprot)
3372 
      self._iprot.readMessageEnd()
3373 
      raise x
3374 
    result = markOrderDoaRequestReceived_result()
3375 
    result.read(self._iprot)
3376 
    self._iprot.readMessageEnd()
3377 
    if result.success is not None:
3378 
      return result.success
3379 
    if result.ex is not None:
3380 
      raise result.ex
3381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3382 
 
3383 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3384 
    """
3385 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3386 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3387 
 
3388 
    Parameters:
3389 
     - orderId
3390 
     - isAuthorized
3391 
    """
3392 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3393 
    return self.recv_markOrderDoaRequestAuthorized()
3394 
 
3395 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3396 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3397 
    args = markOrderDoaRequestAuthorized_args()
3398 
    args.orderId = orderId
3399 
    args.isAuthorized = isAuthorized
3400 
    args.write(self._oprot)
3401 
    self._oprot.writeMessageEnd()
3402 
    self._oprot.trans.flush()
3403 
 
3404 
  def recv_markOrderDoaRequestAuthorized(self, ):
3405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3406 
    if mtype == TMessageType.EXCEPTION:
3407 
      x = TApplicationException()
3408 
      x.read(self._iprot)
3409 
      self._iprot.readMessageEnd()
3410 
      raise x
3411 
    result = markOrderDoaRequestAuthorized_result()
3412 
    result.read(self._iprot)
3413 
    self._iprot.readMessageEnd()
3414 
    if result.success is not None:
3415 
      return result.success
3416 
    if result.ex is not None:
3417 
      raise result.ex
3418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3419 
 
4488 rajveer 3420 
  def markOrderReturnRequestReceived(self, orderId):
3421 
    """
3422 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3423 
 
3424 
    Parameters:
3425 
     - orderId
3426 
    """
3427 
    self.send_markOrderReturnRequestReceived(orderId)
3428 
    return self.recv_markOrderReturnRequestReceived()
3429 
 
3430 
  def send_markOrderReturnRequestReceived(self, orderId):
3431 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3432 
    args = markOrderReturnRequestReceived_args()
3433 
    args.orderId = orderId
3434 
    args.write(self._oprot)
3435 
    self._oprot.writeMessageEnd()
3436 
    self._oprot.trans.flush()
3437 
 
3438 
  def recv_markOrderReturnRequestReceived(self, ):
3439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3440 
    if mtype == TMessageType.EXCEPTION:
3441 
      x = TApplicationException()
3442 
      x.read(self._iprot)
3443 
      self._iprot.readMessageEnd()
3444 
      raise x
3445 
    result = markOrderReturnRequestReceived_result()
3446 
    result.read(self._iprot)
3447 
    self._iprot.readMessageEnd()
3448 
    if result.success is not None:
3449 
      return result.success
3450 
    if result.ex is not None:
3451 
      raise result.ex
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3453 
 
3454 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3455 
    """
3456 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3457 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3458 
 
3459 
    Parameters:
3460 
     - orderId
3461 
     - isAuthorized
3462 
    """
3463 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3464 
    return self.recv_markOrderReturnRequestAuthorized()
3465 
 
3466 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3467 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3468 
    args = markOrderReturnRequestAuthorized_args()
3469 
    args.orderId = orderId
3470 
    args.isAuthorized = isAuthorized
3471 
    args.write(self._oprot)
3472 
    self._oprot.writeMessageEnd()
3473 
    self._oprot.trans.flush()
3474 
 
3475 
  def recv_markOrderReturnRequestAuthorized(self, ):
3476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3477 
    if mtype == TMessageType.EXCEPTION:
3478 
      x = TApplicationException()
3479 
      x.read(self._iprot)
3480 
      self._iprot.readMessageEnd()
3481 
      raise x
3482 
    result = markOrderReturnRequestAuthorized_result()
3483 
    result.read(self._iprot)
3484 
    self._iprot.readMessageEnd()
3485 
    if result.success is not None:
3486 
      return result.success
3487 
    if result.ex is not None:
3488 
      raise result.ex
3489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3490 
 
4579 rajveer 3491 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3492 
    """
3493 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3494 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3495 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3496 
    For any other status, it returns false.
3497 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3498 
 
2536 chandransh 3499 
    Parameters:
3500 
     - orderId
4579 rajveer 3501 
     - providerId
2536 chandransh 3502 
    """
4579 rajveer 3503 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3504 
    return self.recv_requestPickupNumber()
3505 
 
4579 rajveer 3506 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3507 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3508 
    args = requestPickupNumber_args()
3509 
    args.orderId = orderId
4579 rajveer 3510 
    args.providerId = providerId
2536 chandransh 3511 
    args.write(self._oprot)
3512 
    self._oprot.writeMessageEnd()
3513 
    self._oprot.trans.flush()
3514 
 
3515 
  def recv_requestPickupNumber(self, ):
3516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3517 
    if mtype == TMessageType.EXCEPTION:
3518 
      x = TApplicationException()
3519 
      x.read(self._iprot)
3520 
      self._iprot.readMessageEnd()
3521 
      raise x
3522 
    result = requestPickupNumber_result()
3523 
    result.read(self._iprot)
3524 
    self._iprot.readMessageEnd()
3431 rajveer 3525 
    if result.success is not None:
2536 chandransh 3526 
      return result.success
3431 rajveer 3527 
    if result.ex is not None:
2536 chandransh 3528 
      raise result.ex
3529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3530 
 
4602 rajveer 3531 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3532 
    """
4452 rajveer 3533 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3534 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3535 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3536 
    	3. Returns true
2591 chandransh 3537 
    If the order is in any other status, it returns false.
2536 chandransh 3538 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3539 
 
2536 chandransh 3540 
    Parameters:
3541 
     - orderId
3542 
     - pickupNumber
4602 rajveer 3543 
     - providerId
2536 chandransh 3544 
    """
4602 rajveer 3545 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3546 
    return self.recv_authorizePickup()
3547 
 
4602 rajveer 3548 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3549 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3550 
    args = authorizePickup_args()
3551 
    args.orderId = orderId
3552 
    args.pickupNumber = pickupNumber
4602 rajveer 3553 
    args.providerId = providerId
2536 chandransh 3554 
    args.write(self._oprot)
3555 
    self._oprot.writeMessageEnd()
3556 
    self._oprot.trans.flush()
3557 
 
3558 
  def recv_authorizePickup(self, ):
3559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3560 
    if mtype == TMessageType.EXCEPTION:
3561 
      x = TApplicationException()
3562 
      x.read(self._iprot)
3563 
      self._iprot.readMessageEnd()
3564 
      raise x
3565 
    result = authorizePickup_result()
3566 
    result.read(self._iprot)
3567 
    self._iprot.readMessageEnd()
3431 rajveer 3568 
    if result.success is not None:
2536 chandransh 3569 
      return result.success
3431 rajveer 3570 
    if result.ex is not None:
2536 chandransh 3571 
      raise result.ex
3572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3573 
 
2764 chandransh 3574 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3575 
    """
3576 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3577 
 
2764 chandransh 3578 
    Parameters:
3579 
     - providerId
3580 
     - pickupDetails
3581 
    """
3582 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3583 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3584 
 
3585 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3586 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3587 
    args = markDoasAsPickedUp_args()
3588 
    args.providerId = providerId
3589 
    args.pickupDetails = pickupDetails
3590 
    args.write(self._oprot)
3591 
    self._oprot.writeMessageEnd()
3592 
    self._oprot.trans.flush()
3593 
 
3594 
  def recv_markDoasAsPickedUp(self, ):
3595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3596 
    if mtype == TMessageType.EXCEPTION:
3597 
      x = TApplicationException()
3598 
      x.read(self._iprot)
3599 
      self._iprot.readMessageEnd()
3600 
      raise x
3601 
    result = markDoasAsPickedUp_result()
3602 
    result.read(self._iprot)
3603 
    self._iprot.readMessageEnd()
4910 phani.kuma 3604 
    return
3605 
 
3606 
  def getDoasNotPickedUp(self, providerId):
3607 
    """
3608 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3609 
 
3610 
    Parameters:
3611 
     - providerId
3612 
    """
3613 
    self.send_getDoasNotPickedUp(providerId)
3614 
    return self.recv_getDoasNotPickedUp()
3615 
 
3616 
  def send_getDoasNotPickedUp(self, providerId):
3617 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3618 
    args = getDoasNotPickedUp_args()
3619 
    args.providerId = providerId
3620 
    args.write(self._oprot)
3621 
    self._oprot.writeMessageEnd()
3622 
    self._oprot.trans.flush()
3623 
 
3624 
  def recv_getDoasNotPickedUp(self, ):
3625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3626 
    if mtype == TMessageType.EXCEPTION:
3627 
      x = TApplicationException()
3628 
      x.read(self._iprot)
3629 
      self._iprot.readMessageEnd()
3630 
      raise x
3631 
    result = getDoasNotPickedUp_result()
3632 
    result.read(self._iprot)
3633 
    self._iprot.readMessageEnd()
3431 rajveer 3634 
    if result.success is not None:
2764 chandransh 3635 
      return result.success
4910 phani.kuma 3636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3637 
 
4741 phani.kuma 3638 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3639 
    """
3640 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3641 
 
3642 
    Parameters:
3643 
     - providerId
3644 
     - pickupDetails
3645 
    """
3646 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3647 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3648 
 
3649 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3650 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3651 
    args = markReturnOrdersAsPickedUp_args()
3652 
    args.providerId = providerId
3653 
    args.pickupDetails = pickupDetails
3654 
    args.write(self._oprot)
3655 
    self._oprot.writeMessageEnd()
3656 
    self._oprot.trans.flush()
3657 
 
3658 
  def recv_markReturnOrdersAsPickedUp(self, ):
3659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3660 
    if mtype == TMessageType.EXCEPTION:
3661 
      x = TApplicationException()
3662 
      x.read(self._iprot)
3663 
      self._iprot.readMessageEnd()
3664 
      raise x
3665 
    result = markReturnOrdersAsPickedUp_result()
3666 
    result.read(self._iprot)
3667 
    self._iprot.readMessageEnd()
4910 phani.kuma 3668 
    return
3669 
 
3670 
  def getReturnOrdersNotPickedUp(self, providerId):
3671 
    """
3672 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3673 
 
3674 
    Parameters:
3675 
     - providerId
3676 
    """
3677 
    self.send_getReturnOrdersNotPickedUp(providerId)
3678 
    return self.recv_getReturnOrdersNotPickedUp()
3679 
 
3680 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3681 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3682 
    args = getReturnOrdersNotPickedUp_args()
3683 
    args.providerId = providerId
3684 
    args.write(self._oprot)
3685 
    self._oprot.writeMessageEnd()
3686 
    self._oprot.trans.flush()
3687 
 
3688 
  def recv_getReturnOrdersNotPickedUp(self, ):
3689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3690 
    if mtype == TMessageType.EXCEPTION:
3691 
      x = TApplicationException()
3692 
      x.read(self._iprot)
3693 
      self._iprot.readMessageEnd()
3694 
      raise x
3695 
    result = getReturnOrdersNotPickedUp_result()
3696 
    result.read(self._iprot)
3697 
    self._iprot.readMessageEnd()
4741 phani.kuma 3698 
    if result.success is not None:
3699 
      return result.success
4910 phani.kuma 3700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3701 
 
4479 rajveer 3702 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3703 
    """
4452 rajveer 3704 
    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 3705 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3706 
    If the order is in any other state, it returns false.
3707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3708 
 
2591 chandransh 3709 
    Parameters:
3710 
     - orderId
4479 rajveer 3711 
     - receiveCondition
2591 chandransh 3712 
    """
4479 rajveer 3713 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3714 
    return self.recv_receiveReturn()
2536 chandransh 3715 
 
4479 rajveer 3716 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3717 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3718 
    args = receiveReturn_args()
2591 chandransh 3719 
    args.orderId = orderId
4479 rajveer 3720 
    args.receiveCondition = receiveCondition
2591 chandransh 3721 
    args.write(self._oprot)
3722 
    self._oprot.writeMessageEnd()
3723 
    self._oprot.trans.flush()
3724 
 
2616 chandransh 3725 
  def recv_receiveReturn(self, ):
2591 chandransh 3726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3727 
    if mtype == TMessageType.EXCEPTION:
3728 
      x = TApplicationException()
3729 
      x.read(self._iprot)
3730 
      self._iprot.readMessageEnd()
3731 
      raise x
2616 chandransh 3732 
    result = receiveReturn_result()
2591 chandransh 3733 
    result.read(self._iprot)
3734 
    self._iprot.readMessageEnd()
3431 rajveer 3735 
    if result.success is not None:
2591 chandransh 3736 
      return result.success
3431 rajveer 3737 
    if result.ex is not None:
2591 chandransh 3738 
      raise result.ex
2616 chandransh 3739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3740 
 
3741 
  def validateDoa(self, orderId, isValid):
3742 
    """
4452 rajveer 3743 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3744 
    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 3745 
    If the order is in any other state, it returns false.
3746 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3747 
 
2591 chandransh 3748 
    Parameters:
3749 
     - orderId
3750 
     - isValid
3751 
    """
3752 
    self.send_validateDoa(orderId, isValid)
3753 
    return self.recv_validateDoa()
3754 
 
3755 
  def send_validateDoa(self, orderId, isValid):
3756 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3757 
    args = validateDoa_args()
3758 
    args.orderId = orderId
3759 
    args.isValid = isValid
3760 
    args.write(self._oprot)
3761 
    self._oprot.writeMessageEnd()
3762 
    self._oprot.trans.flush()
3763 
 
3764 
  def recv_validateDoa(self, ):
3765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3766 
    if mtype == TMessageType.EXCEPTION:
3767 
      x = TApplicationException()
3768 
      x.read(self._iprot)
3769 
      self._iprot.readMessageEnd()
3770 
      raise x
3771 
    result = validateDoa_result()
3772 
    result.read(self._iprot)
3773 
    self._iprot.readMessageEnd()
3431 rajveer 3774 
    if result.success is not None:
2591 chandransh 3775 
      return result.success
3431 rajveer 3776 
    if result.ex is not None:
2591 chandransh 3777 
      raise result.ex
3778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3779 
 
4495 rajveer 3780 
  def validateReturnProduct(self, orderId, isUsable):
3781 
    """
3782 
    Parameters:
3783 
     - orderId
3784 
     - isUsable
3785 
    """
3786 
    self.send_validateReturnProduct(orderId, isUsable)
3787 
    return self.recv_validateReturnProduct()
3788 
 
3789 
  def send_validateReturnProduct(self, orderId, isUsable):
3790 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3791 
    args = validateReturnProduct_args()
3792 
    args.orderId = orderId
3793 
    args.isUsable = isUsable
3794 
    args.write(self._oprot)
3795 
    self._oprot.writeMessageEnd()
3796 
    self._oprot.trans.flush()
3797 
 
3798 
  def recv_validateReturnProduct(self, ):
3799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3800 
    if mtype == TMessageType.EXCEPTION:
3801 
      x = TApplicationException()
3802 
      x.read(self._iprot)
3803 
      self._iprot.readMessageEnd()
3804 
      raise x
3805 
    result = validateReturnProduct_result()
3806 
    result.read(self._iprot)
3807 
    self._iprot.readMessageEnd()
3808 
    if result.success is not None:
3809 
      return result.success
3810 
    if result.ex is not None:
3811 
      raise result.ex
3812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3813 
 
2616 chandransh 3814 
  def reshipOrder(self, orderId):
3815 
    """
4484 rajveer 3816 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3817 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3818 
    	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 3819 
 
3820 
    If the order is in DOA_CERT_VALID state, it does the following:
3821 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3822 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3823 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3824 
 
2616 chandransh 3825 
    Returns the id of the newly created order.
3431 rajveer 3826 
 
2616 chandransh 3827 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3828 
 
2616 chandransh 3829 
    Parameters:
3830 
     - orderId
3831 
    """
3832 
    self.send_reshipOrder(orderId)
3833 
    return self.recv_reshipOrder()
2591 chandransh 3834 
 
2616 chandransh 3835 
  def send_reshipOrder(self, orderId):
3836 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3837 
    args = reshipOrder_args()
3838 
    args.orderId = orderId
3839 
    args.write(self._oprot)
3840 
    self._oprot.writeMessageEnd()
3841 
    self._oprot.trans.flush()
3842 
 
3843 
  def recv_reshipOrder(self, ):
3844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3845 
    if mtype == TMessageType.EXCEPTION:
3846 
      x = TApplicationException()
3847 
      x.read(self._iprot)
3848 
      self._iprot.readMessageEnd()
3849 
      raise x
3850 
    result = reshipOrder_result()
3851 
    result.read(self._iprot)
3852 
    self._iprot.readMessageEnd()
3431 rajveer 3853 
    if result.success is not None:
2616 chandransh 3854 
      return result.success
3431 rajveer 3855 
    if result.ex is not None:
2616 chandransh 3856 
      raise result.ex
3857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3858 
 
3226 chandransh 3859 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3860 
    """
4484 rajveer 3861 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3862 
    	1. Creates a refund request for batch processing.
3863 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3864 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3865 
 
2616 chandransh 3866 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3867 
    	1. Creates a refund request for batch processing.
3226 chandransh 3868 
    	2. Cancels the reservation of the item in the warehouse.
3869 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3870 
 
3226 chandransh 3871 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3872 
    	1. Cancels the reservation of the item in the warehouse.
3873 
    	2. Marks the current order as CANCELED.
3874 
 
3875 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3876 
 
2616 chandransh 3877 
    Returns True if it is successful, False otherwise.
3431 rajveer 3878 
 
2616 chandransh 3879 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3880 
 
2616 chandransh 3881 
    Parameters:
3882 
     - orderId
3226 chandransh 3883 
     - refundedBy
3884 
     - reason
2616 chandransh 3885 
    """
3226 chandransh 3886 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3887 
    return self.recv_refundOrder()
3888 
 
3226 chandransh 3889 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3890 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3891 
    args = refundOrder_args()
3892 
    args.orderId = orderId
3226 chandransh 3893 
    args.refundedBy = refundedBy
3894 
    args.reason = reason
2616 chandransh 3895 
    args.write(self._oprot)
3896 
    self._oprot.writeMessageEnd()
3897 
    self._oprot.trans.flush()
3898 
 
3899 
  def recv_refundOrder(self, ):
3900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3901 
    if mtype == TMessageType.EXCEPTION:
3902 
      x = TApplicationException()
3903 
      x.read(self._iprot)
3904 
      self._iprot.readMessageEnd()
3905 
      raise x
3906 
    result = refundOrder_result()
3907 
    result.read(self._iprot)
3908 
    self._iprot.readMessageEnd()
3431 rajveer 3909 
    if result.success is not None:
2616 chandransh 3910 
      return result.success
3431 rajveer 3911 
    if result.ex is not None:
2616 chandransh 3912 
      raise result.ex
3913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3914 
 
2690 chandransh 3915 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3916 
    """
3917 
    Get all return orders created between the from and to dates for the given warehouse.
3918 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3919 
 
2690 chandransh 3920 
    Parameters:
3921 
     - warehouseId
3922 
     - fromDate
3923 
     - toDate
3924 
    """
3925 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3926 
    return self.recv_getReturnOrders()
2616 chandransh 3927 
 
2690 chandransh 3928 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3929 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3930 
    args = getReturnOrders_args()
3931 
    args.warehouseId = warehouseId
3932 
    args.fromDate = fromDate
3933 
    args.toDate = toDate
3934 
    args.write(self._oprot)
3935 
    self._oprot.writeMessageEnd()
3936 
    self._oprot.trans.flush()
3937 
 
3938 
  def recv_getReturnOrders(self, ):
3939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3940 
    if mtype == TMessageType.EXCEPTION:
3941 
      x = TApplicationException()
3942 
      x.read(self._iprot)
3943 
      self._iprot.readMessageEnd()
3944 
      raise x
3945 
    result = getReturnOrders_result()
3946 
    result.read(self._iprot)
3947 
    self._iprot.readMessageEnd()
3431 rajveer 3948 
    if result.success is not None:
2690 chandransh 3949 
      return result.success
3950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3951 
 
5481 phani.kuma 3952 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3953 
    """
3954 
    Get all return orders created between the from and to dates.
3955 
 
3956 
    Parameters:
3957 
     - onlyNotProcessed
3958 
     - fromDate
3959 
     - toDate
3960 
    """
3961 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3962 
    return self.recv_getAllReturnOrders()
3963 
 
3964 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3965 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3966 
    args = getAllReturnOrders_args()
3967 
    args.onlyNotProcessed = onlyNotProcessed
3968 
    args.fromDate = fromDate
3969 
    args.toDate = toDate
3970 
    args.write(self._oprot)
3971 
    self._oprot.writeMessageEnd()
3972 
    self._oprot.trans.flush()
3973 
 
3974 
  def recv_getAllReturnOrders(self, ):
3975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3976 
    if mtype == TMessageType.EXCEPTION:
3977 
      x = TApplicationException()
3978 
      x.read(self._iprot)
3979 
      self._iprot.readMessageEnd()
3980 
      raise x
3981 
    result = getAllReturnOrders_result()
3982 
    result.read(self._iprot)
3983 
    self._iprot.readMessageEnd()
3984 
    if result.success is not None:
3985 
      return result.success
3986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3987 
 
2700 chandransh 3988 
  def getReturnOrder(self, id):
3989 
    """
3990 
    Returns the ReturnOrder corresponding to the given id.
3991 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3992 
 
2700 chandransh 3993 
    Parameters:
3994 
     - id
3995 
    """
3996 
    self.send_getReturnOrder(id)
3997 
    return self.recv_getReturnOrder()
3998 
 
3999 
  def send_getReturnOrder(self, id):
4000 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4001 
    args = getReturnOrder_args()
4002 
    args.id = id
4003 
    args.write(self._oprot)
4004 
    self._oprot.writeMessageEnd()
4005 
    self._oprot.trans.flush()
4006 
 
4007 
  def recv_getReturnOrder(self, ):
4008 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4009 
    if mtype == TMessageType.EXCEPTION:
4010 
      x = TApplicationException()
4011 
      x.read(self._iprot)
4012 
      self._iprot.readMessageEnd()
4013 
      raise x
4014 
    result = getReturnOrder_result()
4015 
    result.read(self._iprot)
4016 
    self._iprot.readMessageEnd()
3431 rajveer 4017 
    if result.success is not None:
2700 chandransh 4018 
      return result.success
3431 rajveer 4019 
    if result.ex is not None:
2700 chandransh 4020 
      raise result.ex
4021 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4022 
 
2690 chandransh 4023 
  def processReturn(self, returnOrderId):
4024 
    """
4025 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4026 
 
2690 chandransh 4027 
    Parameters:
4028 
     - returnOrderId
4029 
    """
4030 
    self.send_processReturn(returnOrderId)
4031 
    self.recv_processReturn()
4032 
 
4033 
  def send_processReturn(self, returnOrderId):
4034 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4035 
    args = processReturn_args()
4036 
    args.returnOrderId = returnOrderId
4037 
    args.write(self._oprot)
4038 
    self._oprot.writeMessageEnd()
4039 
    self._oprot.trans.flush()
4040 
 
4041 
  def recv_processReturn(self, ):
4042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4043 
    if mtype == TMessageType.EXCEPTION:
4044 
      x = TApplicationException()
4045 
      x.read(self._iprot)
4046 
      self._iprot.readMessageEnd()
4047 
      raise x
4048 
    result = processReturn_result()
4049 
    result.read(self._iprot)
4050 
    self._iprot.readMessageEnd()
3431 rajveer 4051 
    if result.ex is not None:
2690 chandransh 4052 
      raise result.ex
4053 
    return
4054 
 
3451 chandransh 4055 
  def updateWeight(self, orderId, weight):
4056 
    """
4057 
    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 4058 
 
3451 chandransh 4059 
    Parameters:
4060 
     - orderId
4061 
     - weight
4062 
    """
4063 
    self.send_updateWeight(orderId, weight)
4064 
    return self.recv_updateWeight()
4065 
 
4066 
  def send_updateWeight(self, orderId, weight):
4067 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4068 
    args = updateWeight_args()
4069 
    args.orderId = orderId
4070 
    args.weight = weight
4071 
    args.write(self._oprot)
4072 
    self._oprot.writeMessageEnd()
4073 
    self._oprot.trans.flush()
4074 
 
4075 
  def recv_updateWeight(self, ):
4076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4077 
    if mtype == TMessageType.EXCEPTION:
4078 
      x = TApplicationException()
4079 
      x.read(self._iprot)
4080 
      self._iprot.readMessageEnd()
4081 
      raise x
4082 
    result = updateWeight_result()
4083 
    result.read(self._iprot)
4084 
    self._iprot.readMessageEnd()
4085 
    if result.success is not None:
4086 
      return result.success
4087 
    if result.ex is not None:
4088 
      raise result.ex
4089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4090 
 
3469 chandransh 4091 
  def changeItem(self, orderId, itemId):
4092 
    """
4093 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4094 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4095 
 
3469 chandransh 4096 
    Parameters:
4097 
     - orderId
4098 
     - itemId
4099 
    """
4100 
    self.send_changeItem(orderId, itemId)
4101 
    return self.recv_changeItem()
4102 
 
4103 
  def send_changeItem(self, orderId, itemId):
4104 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4105 
    args = changeItem_args()
4106 
    args.orderId = orderId
4107 
    args.itemId = itemId
4108 
    args.write(self._oprot)
4109 
    self._oprot.writeMessageEnd()
4110 
    self._oprot.trans.flush()
4111 
 
4112 
  def recv_changeItem(self, ):
4113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4114 
    if mtype == TMessageType.EXCEPTION:
4115 
      x = TApplicationException()
4116 
      x.read(self._iprot)
4117 
      self._iprot.readMessageEnd()
4118 
      raise x
4119 
    result = changeItem_result()
4120 
    result.read(self._iprot)
4121 
    self._iprot.readMessageEnd()
4122 
    if result.success is not None:
4123 
      return result.success
4124 
    if result.ex is not None:
4125 
      raise result.ex
4126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4127 
 
4128 
  def shiftToWarehouse(self, orderId, warehouseId):
4129 
    """
4130 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4131 
 
4132 
    Parameters:
4133 
     - orderId
4134 
     - warehouseId
4135 
    """
4136 
    self.send_shiftToWarehouse(orderId, warehouseId)
4137 
    return self.recv_shiftToWarehouse()
4138 
 
4139 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4140 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4141 
    args = shiftToWarehouse_args()
4142 
    args.orderId = orderId
4143 
    args.warehouseId = warehouseId
4144 
    args.write(self._oprot)
4145 
    self._oprot.writeMessageEnd()
4146 
    self._oprot.trans.flush()
4147 
 
4148 
  def recv_shiftToWarehouse(self, ):
4149 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4150 
    if mtype == TMessageType.EXCEPTION:
4151 
      x = TApplicationException()
4152 
      x.read(self._iprot)
4153 
      self._iprot.readMessageEnd()
4154 
      raise x
4155 
    result = shiftToWarehouse_result()
4156 
    result.read(self._iprot)
4157 
    self._iprot.readMessageEnd()
4158 
    if result.success is not None:
4159 
      return result.success
4160 
    if result.ex is not None:
4161 
      raise result.ex
4162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4163 
 
4647 rajveer 4164 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4165 
    """
4166 
    Adds the given delay reason to the given order.
3986 chandransh 4167 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4168 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4169 
 
3553 chandransh 4170 
    Parameters:
4171 
     - orderId
4172 
     - delayReason
3986 chandransh 4173 
     - furtherDelay
4647 rajveer 4174 
     - delayReasonText
3553 chandransh 4175 
    """
4647 rajveer 4176 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4177 
    return self.recv_addDelayReason()
4178 
 
4647 rajveer 4179 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4180 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4181 
    args = addDelayReason_args()
4182 
    args.orderId = orderId
4183 
    args.delayReason = delayReason
3986 chandransh 4184 
    args.furtherDelay = furtherDelay
4647 rajveer 4185 
    args.delayReasonText = delayReasonText
3553 chandransh 4186 
    args.write(self._oprot)
4187 
    self._oprot.writeMessageEnd()
4188 
    self._oprot.trans.flush()
4189 
 
4190 
  def recv_addDelayReason(self, ):
4191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4192 
    if mtype == TMessageType.EXCEPTION:
4193 
      x = TApplicationException()
4194 
      x.read(self._iprot)
4195 
      self._iprot.readMessageEnd()
4196 
      raise x
4197 
    result = addDelayReason_result()
4198 
    result.read(self._iprot)
4199 
    self._iprot.readMessageEnd()
4200 
    if result.success is not None:
4201 
      return result.success
4202 
    if result.ex is not None:
4203 
      raise result.ex
4204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4205 
 
3956 chandransh 4206 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4207 
    """
4208 
    Marks the COD orders with given AWB nos. as having been processed.
4209 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4210 
 
3956 chandransh 4211 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4212 
    1. There is no order corresponding to an AWB number.
4213 
    2. The captured amount for a payment exceeds the total payment.
4214 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4215 
 
4216 
    Parameters:
4217 
     - collectedAmountMap
4218 
     - xferBy
4219 
     - xferTxnId
4220 
     - xferDate
4221 
    """
4222 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4223 
    return self.recv_reconcileCodCollection()
4224 
 
4225 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4226 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4227 
    args = reconcileCodCollection_args()
4228 
    args.collectedAmountMap = collectedAmountMap
4229 
    args.xferBy = xferBy
4230 
    args.xferTxnId = xferTxnId
4231 
    args.xferDate = xferDate
4232 
    args.write(self._oprot)
4233 
    self._oprot.writeMessageEnd()
4234 
    self._oprot.trans.flush()
4235 
 
4236 
  def recv_reconcileCodCollection(self, ):
4237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4238 
    if mtype == TMessageType.EXCEPTION:
4239 
      x = TApplicationException()
4240 
      x.read(self._iprot)
4241 
      self._iprot.readMessageEnd()
4242 
      raise x
4243 
    result = reconcileCodCollection_result()
4244 
    result.read(self._iprot)
4245 
    self._iprot.readMessageEnd()
4246 
    if result.success is not None:
4247 
      return result.success
4248 
    if result.ex is not None:
4249 
      raise result.ex
4250 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4251 
 
4008 mandeep.dh 4252 
  def getTransactionsRequiringExtraProcessing(self, category):
4253 
    """
4065 mandeep.dh 4254 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4255 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4256 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4257 
 
4008 mandeep.dh 4258 
    Parameters:
4259 
     - category
4260 
    """
4261 
    self.send_getTransactionsRequiringExtraProcessing(category)
4262 
    return self.recv_getTransactionsRequiringExtraProcessing()
4263 
 
4264 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4265 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4266 
    args = getTransactionsRequiringExtraProcessing_args()
4267 
    args.category = category
4268 
    args.write(self._oprot)
4269 
    self._oprot.writeMessageEnd()
4270 
    self._oprot.trans.flush()
4271 
 
4272 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4274 
    if mtype == TMessageType.EXCEPTION:
4275 
      x = TApplicationException()
4276 
      x.read(self._iprot)
4277 
      self._iprot.readMessageEnd()
4278 
      raise x
4279 
    result = getTransactionsRequiringExtraProcessing_result()
4280 
    result.read(self._iprot)
4281 
    self._iprot.readMessageEnd()
4282 
    if result.success is not None:
4283 
      return result.success
4284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4285 
 
4286 
  def markTransactionAsProcessed(self, transactionId, category):
4287 
    """
4288 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4289 
    It essentially deletes the transaction id record for a particular
4290 
    processing type category (if present) from DB.
4291 
    This is currently used by CRM application.
4008 mandeep.dh 4292 
 
4293 
    Parameters:
4294 
     - transactionId
4295 
     - category
4296 
    """
4297 
    self.send_markTransactionAsProcessed(transactionId, category)
4298 
    self.recv_markTransactionAsProcessed()
4299 
 
4300 
  def send_markTransactionAsProcessed(self, transactionId, category):
4301 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4302 
    args = markTransactionAsProcessed_args()
4303 
    args.transactionId = transactionId
4304 
    args.category = category
4305 
    args.write(self._oprot)
4306 
    self._oprot.writeMessageEnd()
4307 
    self._oprot.trans.flush()
4308 
 
4309 
  def recv_markTransactionAsProcessed(self, ):
4310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4311 
    if mtype == TMessageType.EXCEPTION:
4312 
      x = TApplicationException()
4313 
      x.read(self._iprot)
4314 
      self._iprot.readMessageEnd()
4315 
      raise x
4316 
    result = markTransactionAsProcessed_result()
4317 
    result.read(self._iprot)
4318 
    self._iprot.readMessageEnd()
4319 
    return
4320 
 
4018 chandransh 4321 
  def getItemWiseRiskyOrdersCount(self, ):
4322 
    """
4323 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4324 
    is defined as one whose shipping date is about to expire.
4325 
    """
4326 
    self.send_getItemWiseRiskyOrdersCount()
4327 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4328 
 
4018 chandransh 4329 
  def send_getItemWiseRiskyOrdersCount(self, ):
4330 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4331 
    args = getItemWiseRiskyOrdersCount_args()
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_getItemWiseRiskyOrdersCount(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 = getItemWiseRiskyOrdersCount_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    if result.success is not None:
4347 
      return result.success
4348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4349 
 
4295 varun.gupt 4350 
  def getOrdersForItemIds(self, itemIds):
4351 
    """
4352 
    Returns a list of all orders which have items with given id
4353 
 
4354 
    Parameters:
4355 
     - itemIds
4356 
    """
4357 
    self.send_getOrdersForItemIds(itemIds)
4358 
    return self.recv_getOrdersForItemIds()
4359 
 
4360 
  def send_getOrdersForItemIds(self, itemIds):
4361 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4362 
    args = getOrdersForItemIds_args()
4363 
    args.itemIds = itemIds
4364 
    args.write(self._oprot)
4365 
    self._oprot.writeMessageEnd()
4366 
    self._oprot.trans.flush()
4367 
 
4368 
  def recv_getOrdersForItemIds(self, ):
4369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4370 
    if mtype == TMessageType.EXCEPTION:
4371 
      x = TApplicationException()
4372 
      x.read(self._iprot)
4373 
      self._iprot.readMessageEnd()
4374 
      raise x
4375 
    result = getOrdersForItemIds_result()
4376 
    result.read(self._iprot)
4377 
    self._iprot.readMessageEnd()
4378 
    if result.success is not None:
4379 
      return result.success
4380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4381 
 
4247 rajveer 4382 
  def markOrderCancellationRequestReceived(self, orderId):
4383 
    """
4384 
    Mark order as cancellation request received. If customer sends request of cancellation of
4385 
    a particular order, this method will be called. It will just change status of the order
4386 
    depending on its current status. It also records the previous status, so that we can move
4387 
    back to that status if cancellation request is denied.
4018 chandransh 4388 
 
4247 rajveer 4389 
    Parameters:
4390 
     - orderId
4391 
    """
4392 
    self.send_markOrderCancellationRequestReceived(orderId)
4393 
    self.recv_markOrderCancellationRequestReceived()
4394 
 
4395 
  def send_markOrderCancellationRequestReceived(self, orderId):
4396 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4397 
    args = markOrderCancellationRequestReceived_args()
4398 
    args.orderId = orderId
4399 
    args.write(self._oprot)
4400 
    self._oprot.writeMessageEnd()
4401 
    self._oprot.trans.flush()
4402 
 
4403 
  def recv_markOrderCancellationRequestReceived(self, ):
4404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4405 
    if mtype == TMessageType.EXCEPTION:
4406 
      x = TApplicationException()
4407 
      x.read(self._iprot)
4408 
      self._iprot.readMessageEnd()
4409 
      raise x
4410 
    result = markOrderCancellationRequestReceived_result()
4411 
    result.read(self._iprot)
4412 
    self._iprot.readMessageEnd()
4413 
    if result.ex is not None:
4414 
      raise result.ex
4415 
    return
4416 
 
4417 
  def markOrderCancellationRequestConfirmed(self, orderId):
4418 
    """
4419 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4420 
    cancellation request confirmed. After this OM will be able to cancel the order.
4421 
 
4422 
    Parameters:
4423 
     - orderId
4424 
    """
4425 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4426 
    self.recv_markOrderCancellationRequestConfirmed()
4427 
 
4428 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4429 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4430 
    args = markOrderCancellationRequestConfirmed_args()
4431 
    args.orderId = orderId
4432 
    args.write(self._oprot)
4433 
    self._oprot.writeMessageEnd()
4434 
    self._oprot.trans.flush()
4435 
 
4436 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4438 
    if mtype == TMessageType.EXCEPTION:
4439 
      x = TApplicationException()
4440 
      x.read(self._iprot)
4441 
      self._iprot.readMessageEnd()
4442 
      raise x
4443 
    result = markOrderCancellationRequestConfirmed_result()
4444 
    result.read(self._iprot)
4445 
    self._iprot.readMessageEnd()
4446 
    if result.ex is not None:
4447 
      raise result.ex
4448 
    return
4449 
 
4450 
  def markOrderCancellationRequestDenied(self, orderId):
4451 
    """
4452 
    If we decide to not to cancel order, we will move the order ro previous status.
4453 
 
4454 
    Parameters:
4455 
     - orderId
4456 
    """
4457 
    self.send_markOrderCancellationRequestDenied(orderId)
4458 
    self.recv_markOrderCancellationRequestDenied()
4459 
 
4460 
  def send_markOrderCancellationRequestDenied(self, orderId):
4461 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4462 
    args = markOrderCancellationRequestDenied_args()
4463 
    args.orderId = orderId
4464 
    args.write(self._oprot)
4465 
    self._oprot.writeMessageEnd()
4466 
    self._oprot.trans.flush()
4467 
 
4468 
  def recv_markOrderCancellationRequestDenied(self, ):
4469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4470 
    if mtype == TMessageType.EXCEPTION:
4471 
      x = TApplicationException()
4472 
      x.read(self._iprot)
4473 
      self._iprot.readMessageEnd()
4474 
      raise x
4475 
    result = markOrderCancellationRequestDenied_result()
4476 
    result.read(self._iprot)
4477 
    self._iprot.readMessageEnd()
4478 
    if result.ex is not None:
4479 
      raise result.ex
4480 
    return
4481 
 
4258 rajveer 4482 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4483 
    """
4258 rajveer 4484 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4485 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4486 
 
4487 
    Parameters:
4258 rajveer 4488 
     - transactionId
4247 rajveer 4489 
    """
4258 rajveer 4490 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4491 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4492 
 
4258 rajveer 4493 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4494 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4495 
    args = markTransactionAsPaymentFlagRemoved_args()
4496 
    args.transactionId = transactionId
4247 rajveer 4497 
    args.write(self._oprot)
4498 
    self._oprot.writeMessageEnd()
4499 
    self._oprot.trans.flush()
4500 
 
4258 rajveer 4501 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4503 
    if mtype == TMessageType.EXCEPTION:
4504 
      x = TApplicationException()
4505 
      x.read(self._iprot)
4506 
      self._iprot.readMessageEnd()
4507 
      raise x
4258 rajveer 4508 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4509 
    result.read(self._iprot)
4510 
    self._iprot.readMessageEnd()
4511 
    if result.ex is not None:
4512 
      raise result.ex
4513 
    return
4514 
 
4259 anupam.sin 4515 
  def refundTransaction(self, transactionId, refundedBy, reason):
4516 
    """
4517 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4518 
    need to be cancelled
4247 rajveer 4519 
 
4259 anupam.sin 4520 
    Parameters:
4521 
     - transactionId
4522 
     - refundedBy
4523 
     - reason
4524 
    """
4525 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4526 
    self.recv_refundTransaction()
4527 
 
4528 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4529 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4530 
    args = refundTransaction_args()
4531 
    args.transactionId = transactionId
4532 
    args.refundedBy = refundedBy
4533 
    args.reason = reason
4534 
    args.write(self._oprot)
4535 
    self._oprot.writeMessageEnd()
4536 
    self._oprot.trans.flush()
4537 
 
4538 
  def recv_refundTransaction(self, ):
4539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4540 
    if mtype == TMessageType.EXCEPTION:
4541 
      x = TApplicationException()
4542 
      x.read(self._iprot)
4543 
      self._iprot.readMessageEnd()
4544 
      raise x
4545 
    result = refundTransaction_result()
4546 
    result.read(self._iprot)
4547 
    self._iprot.readMessageEnd()
4548 
    if result.ex is not None:
4549 
      raise result.ex
4550 
    return
4551 
 
4324 mandeep.dh 4552 
  def updateShipmentAddress(self, orderId, addressId):
4553 
    """
4554 
    Updates shipment address of an order. Delivery and shipping date estimates
4555 
    etc. are also updated here.
4556 
 
4557 
    Throws TransactionServiceException in case address change is not
4558 
    possible due to certain reasons such as new pincode in address is
4559 
    not serviceable etc.
4560 
 
4561 
    Parameters:
4562 
     - orderId
4563 
     - addressId
4564 
    """
4565 
    self.send_updateShipmentAddress(orderId, addressId)
4566 
    self.recv_updateShipmentAddress()
4567 
 
4568 
  def send_updateShipmentAddress(self, orderId, addressId):
4569 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4570 
    args = updateShipmentAddress_args()
4571 
    args.orderId = orderId
4572 
    args.addressId = addressId
4573 
    args.write(self._oprot)
4574 
    self._oprot.writeMessageEnd()
4575 
    self._oprot.trans.flush()
4576 
 
4577 
  def recv_updateShipmentAddress(self, ):
4578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4579 
    if mtype == TMessageType.EXCEPTION:
4580 
      x = TApplicationException()
4581 
      x.read(self._iprot)
4582 
      self._iprot.readMessageEnd()
4583 
      raise x
4584 
    result = updateShipmentAddress_result()
4585 
    result.read(self._iprot)
4586 
    self._iprot.readMessageEnd()
4587 
    if result.ex is not None:
4588 
      raise result.ex
4589 
    return
4590 
 
4285 rajveer 4591 
  def acceptOrdersForItemId(self, itemId, inventory):
4592 
    """
4593 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4594 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4595 
 
4285 rajveer 4596 
    Parameters:
4597 
     - itemId
4598 
     - inventory
4599 
    """
4600 
    self.send_acceptOrdersForItemId(itemId, inventory)
4601 
    return self.recv_acceptOrdersForItemId()
4602 
 
4603 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4604 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4605 
    args = acceptOrdersForItemId_args()
4606 
    args.itemId = itemId
4607 
    args.inventory = inventory
4608 
    args.write(self._oprot)
4609 
    self._oprot.writeMessageEnd()
4610 
    self._oprot.trans.flush()
4611 
 
4612 
  def recv_acceptOrdersForItemId(self, ):
4613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4614 
    if mtype == TMessageType.EXCEPTION:
4615 
      x = TApplicationException()
4616 
      x.read(self._iprot)
4617 
      self._iprot.readMessageEnd()
4618 
      raise x
4619 
    result = acceptOrdersForItemId_result()
4620 
    result.read(self._iprot)
4621 
    self._iprot.readMessageEnd()
4622 
    if result.success is not None:
4623 
      return result.success
4624 
    if result.ex is not None:
4625 
      raise result.ex
4626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4627 
 
4369 rajveer 4628 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4629 
    """
4630 
    Parameters:
4631 
     - vendorId
4632 
     - itemId
4633 
     - quantity
4634 
     - estimate
4369 rajveer 4635 
     - isReminder
4303 rajveer 4636 
    """
4369 rajveer 4637 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4638 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4639 
 
4369 rajveer 4640 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4641 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4642 
    args = markOrdersAsPORaised_args()
4643 
    args.vendorId = vendorId
4644 
    args.itemId = itemId
4645 
    args.quantity = quantity
4646 
    args.estimate = estimate
4369 rajveer 4647 
    args.isReminder = isReminder
4303 rajveer 4648 
    args.write(self._oprot)
4649 
    self._oprot.writeMessageEnd()
4650 
    self._oprot.trans.flush()
4651 
 
4652 
  def recv_markOrdersAsPORaised(self, ):
4653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4654 
    if mtype == TMessageType.EXCEPTION:
4655 
      x = TApplicationException()
4656 
      x.read(self._iprot)
4657 
      self._iprot.readMessageEnd()
4658 
      raise x
4659 
    result = markOrdersAsPORaised_result()
4660 
    result.read(self._iprot)
4661 
    self._iprot.readMessageEnd()
4662 
    if result.ex is not None:
4663 
      raise result.ex
4664 
    return
4665 
 
4369 rajveer 4666 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4667 
    """
4668 
    Parameters:
4669 
     - vendorId
4670 
     - itemId
4671 
     - quantity
4672 
     - estimate
4369 rajveer 4673 
     - isReminder
4303 rajveer 4674 
    """
4369 rajveer 4675 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4676 
    self.recv_markOrdersAsReversalInitiated()
4677 
 
4369 rajveer 4678 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4679 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4680 
    args = markOrdersAsReversalInitiated_args()
4681 
    args.vendorId = vendorId
4682 
    args.itemId = itemId
4683 
    args.quantity = quantity
4684 
    args.estimate = estimate
4369 rajveer 4685 
    args.isReminder = isReminder
4303 rajveer 4686 
    args.write(self._oprot)
4687 
    self._oprot.writeMessageEnd()
4688 
    self._oprot.trans.flush()
4689 
 
4690 
  def recv_markOrdersAsReversalInitiated(self, ):
4691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4692 
    if mtype == TMessageType.EXCEPTION:
4693 
      x = TApplicationException()
4694 
      x.read(self._iprot)
4695 
      self._iprot.readMessageEnd()
4696 
      raise x
4697 
    result = markOrdersAsReversalInitiated_result()
4698 
    result.read(self._iprot)
4699 
    self._iprot.readMessageEnd()
4700 
    if result.ex is not None:
4701 
      raise result.ex
4702 
    return
4703 
 
4369 rajveer 4704 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4705 
    """
4706 
    Parameters:
4707 
     - vendorId
4708 
     - itemId
4709 
     - quantity
4710 
     - estimate
4369 rajveer 4711 
     - isReminder
4303 rajveer 4712 
    """
4369 rajveer 4713 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4714 
    self.recv_markOrdersAsNotAvailabke()
4715 
 
4369 rajveer 4716 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4717 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4718 
    args = markOrdersAsNotAvailabke_args()
4719 
    args.vendorId = vendorId
4720 
    args.itemId = itemId
4721 
    args.quantity = quantity
4722 
    args.estimate = estimate
4369 rajveer 4723 
    args.isReminder = isReminder
4303 rajveer 4724 
    args.write(self._oprot)
4725 
    self._oprot.writeMessageEnd()
4726 
    self._oprot.trans.flush()
4727 
 
4728 
  def recv_markOrdersAsNotAvailabke(self, ):
4729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4730 
    if mtype == TMessageType.EXCEPTION:
4731 
      x = TApplicationException()
4732 
      x.read(self._iprot)
4733 
      self._iprot.readMessageEnd()
4734 
      raise x
4735 
    result = markOrdersAsNotAvailabke_result()
4736 
    result.read(self._iprot)
4737 
    self._iprot.readMessageEnd()
4738 
    if result.ex is not None:
4739 
      raise result.ex
4740 
    return
4741 
 
4369 rajveer 4742 
  def markOrdersAsTimeout(self, vendorId):
4743 
    """
4744 
    Parameters:
4745 
     - vendorId
4746 
    """
4747 
    self.send_markOrdersAsTimeout(vendorId)
4748 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4749 
 
4369 rajveer 4750 
  def send_markOrdersAsTimeout(self, vendorId):
4751 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4752 
    args = markOrdersAsTimeout_args()
4753 
    args.vendorId = vendorId
4754 
    args.write(self._oprot)
4755 
    self._oprot.writeMessageEnd()
4756 
    self._oprot.trans.flush()
4757 
 
4758 
  def recv_markOrdersAsTimeout(self, ):
4759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4760 
    if mtype == TMessageType.EXCEPTION:
4761 
      x = TApplicationException()
4762 
      x.read(self._iprot)
4763 
      self._iprot.readMessageEnd()
4764 
      raise x
4765 
    result = markOrdersAsTimeout_result()
4766 
    result.read(self._iprot)
4767 
    self._iprot.readMessageEnd()
4768 
    if result.success is not None:
4769 
      return result.success
4770 
    if result.ex is not None:
4771 
      raise result.ex
4772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4773 
 
4662 rajveer 4774 
  def markOrderAsLostInTransit(self, orderId):
4775 
    """
4776 
    Mark order as LOST_IN_TRANSIT
4777 
 
4778 
    Parameters:
4779 
     - orderId
4780 
    """
4781 
    self.send_markOrderAsLostInTransit(orderId)
4782 
    return self.recv_markOrderAsLostInTransit()
4783 
 
4784 
  def send_markOrderAsLostInTransit(self, orderId):
4785 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4786 
    args = markOrderAsLostInTransit_args()
4787 
    args.orderId = orderId
4788 
    args.write(self._oprot)
4789 
    self._oprot.writeMessageEnd()
4790 
    self._oprot.trans.flush()
4791 
 
4792 
  def recv_markOrderAsLostInTransit(self, ):
4793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4794 
    if mtype == TMessageType.EXCEPTION:
4795 
      x = TApplicationException()
4796 
      x.read(self._iprot)
4797 
      self._iprot.readMessageEnd()
4798 
      raise x
4799 
    result = markOrderAsLostInTransit_result()
4800 
    result.read(self._iprot)
4801 
    self._iprot.readMessageEnd()
4802 
    if result.success is not None:
4803 
      return result.success
4804 
    if result.ex is not None:
4805 
      raise result.ex
4806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4807 
 
4386 anupam.sin 4808 
  def getOrderForAwb(self, awb):
4809 
    """
4810 
    Returns the order corresponding to an AWB number
4369 rajveer 4811 
 
4386 anupam.sin 4812 
    Parameters:
4813 
     - awb
4814 
    """
4815 
    self.send_getOrderForAwb(awb)
4816 
    return self.recv_getOrderForAwb()
4817 
 
4818 
  def send_getOrderForAwb(self, awb):
4819 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4820 
    args = getOrderForAwb_args()
4821 
    args.awb = awb
4822 
    args.write(self._oprot)
4823 
    self._oprot.writeMessageEnd()
4824 
    self._oprot.trans.flush()
4825 
 
4826 
  def recv_getOrderForAwb(self, ):
4827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4828 
    if mtype == TMessageType.EXCEPTION:
4829 
      x = TApplicationException()
4830 
      x.read(self._iprot)
4831 
      self._iprot.readMessageEnd()
4832 
      raise x
4833 
    result = getOrderForAwb_result()
4834 
    result.read(self._iprot)
4835 
    self._iprot.readMessageEnd()
4836 
    if result.success is not None:
4837 
      return result.success
4838 
    if result.ex is not None:
4839 
      raise result.ex
4840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4841 
 
4910 phani.kuma 4842 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4843 
    """
4910 phani.kuma 4844 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4845 
 
4506 phani.kuma 4846 
    Parameters:
4847 
     - logistics_provider_id
4910 phani.kuma 4848 
     - order_status_list
4506 phani.kuma 4849 
    """
4910 phani.kuma 4850 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4851 
    return self.recv_getOrdersForProviderForStatus()
4852 
 
4910 phani.kuma 4853 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4854 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4855 
    args = getOrdersForProviderForStatus_args()
4856 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4857 
    args.order_status_list = order_status_list
4506 phani.kuma 4858 
    args.write(self._oprot)
4859 
    self._oprot.writeMessageEnd()
4860 
    self._oprot.trans.flush()
4861 
 
4862 
  def recv_getOrdersForProviderForStatus(self, ):
4863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4864 
    if mtype == TMessageType.EXCEPTION:
4865 
      x = TApplicationException()
4866 
      x.read(self._iprot)
4867 
      self._iprot.readMessageEnd()
4868 
      raise x
4869 
    result = getOrdersForProviderForStatus_result()
4870 
    result.read(self._iprot)
4871 
    self._iprot.readMessageEnd()
4872 
    if result.success is not None:
4873 
      return result.success
4874 
    if result.ex is not None:
4875 
      raise result.ex
4876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4877 
 
4600 varun.gupt 4878 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4879 
    """
4880 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4881 
 
4600 varun.gupt 4882 
    Parameters:
4883 
     - vendorId
4884 
     - billingDateFrom
4885 
     - billingDateTo
4886 
    """
4887 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4888 
    return self.recv_getBilledOrdersForVendor()
4889 
 
4890 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4891 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4892 
    args = getBilledOrdersForVendor_args()
4893 
    args.vendorId = vendorId
4894 
    args.billingDateFrom = billingDateFrom
4895 
    args.billingDateTo = billingDateTo
4896 
    args.write(self._oprot)
4897 
    self._oprot.writeMessageEnd()
4898 
    self._oprot.trans.flush()
4899 
 
4900 
  def recv_getBilledOrdersForVendor(self, ):
4901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4902 
    if mtype == TMessageType.EXCEPTION:
4903 
      x = TApplicationException()
4904 
      x.read(self._iprot)
4905 
      self._iprot.readMessageEnd()
4906 
      raise x
4907 
    result = getBilledOrdersForVendor_result()
4908 
    result.read(self._iprot)
4909 
    self._iprot.readMessageEnd()
4910 
    if result.success is not None:
4911 
      return result.success
4912 
    if result.ex is not None:
4913 
      raise result.ex
4914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4915 
 
4607 rajveer 4916 
  def getSlippedSippingDateOrders(self, ):
4917 
    self.send_getSlippedSippingDateOrders()
4918 
    return self.recv_getSlippedSippingDateOrders()
4919 
 
4920 
  def send_getSlippedSippingDateOrders(self, ):
4921 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4922 
    args = getSlippedSippingDateOrders_args()
4923 
    args.write(self._oprot)
4924 
    self._oprot.writeMessageEnd()
4925 
    self._oprot.trans.flush()
4926 
 
4927 
  def recv_getSlippedSippingDateOrders(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 = getSlippedSippingDateOrders_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, "getSlippedSippingDateOrders failed: unknown result");
4942 
 
4709 rajveer 4943 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4944 
    """
4945 
    Parameters:
4946 
     - cancelDateFrom
4947 
     - cancelDateTo
4948 
    """
4949 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4950 
    return self.recv_getCancelledOrders()
4951 
 
4952 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4953 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4954 
    args = getCancelledOrders_args()
4955 
    args.cancelDateFrom = cancelDateFrom
4956 
    args.cancelDateTo = cancelDateTo
4957 
    args.write(self._oprot)
4958 
    self._oprot.writeMessageEnd()
4959 
    self._oprot.trans.flush()
4960 
 
4961 
  def recv_getCancelledOrders(self, ):
4962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4963 
    if mtype == TMessageType.EXCEPTION:
4964 
      x = TApplicationException()
4965 
      x.read(self._iprot)
4966 
      self._iprot.readMessageEnd()
4967 
      raise x
4968 
    result = getCancelledOrders_result()
4969 
    result.read(self._iprot)
4970 
    self._iprot.readMessageEnd()
4971 
    if result.success is not None:
4972 
      return result.success
4973 
    if result.ex is not None:
4974 
      raise result.ex
4975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4976 
 
4600 varun.gupt 4977 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4978 
    """
4979 
    Parameters:
4980 
     - mapAWBAndAmount
4981 
    """
4982 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4983 
    self.recv_saveBluedartSettlements()
4984 
 
4985 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4986 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4987 
    args = saveBluedartSettlements_args()
4988 
    args.mapAWBAndAmount = mapAWBAndAmount
4989 
    args.write(self._oprot)
4990 
    self._oprot.writeMessageEnd()
4991 
    self._oprot.trans.flush()
4992 
 
4993 
  def recv_saveBluedartSettlements(self, ):
4994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4995 
    if mtype == TMessageType.EXCEPTION:
4996 
      x = TApplicationException()
4997 
      x.read(self._iprot)
4998 
      self._iprot.readMessageEnd()
4999 
      raise x
5000 
    result = saveBluedartSettlements_result()
5001 
    result.read(self._iprot)
5002 
    self._iprot.readMessageEnd()
5003 
    if result.ex is not None:
5004 
      raise result.ex
5005 
    return
5006 
 
4905 varun.gupt 5007 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5008 
    """
5009 
    Parameters:
5010 
     - settlementDate
5011 
     - paymentGatewayId
4905 varun.gupt 5012 
     - referenceId
4600 varun.gupt 5013 
     - serviceTax
5014 
     - otherCharges
5015 
     - netCollection
5016 
    """
4905 varun.gupt 5017 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5018 
    self.recv_savePaymentSettlements()
5019 
 
4905 varun.gupt 5020 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5021 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5022 
    args = savePaymentSettlements_args()
5023 
    args.settlementDate = settlementDate
5024 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5025 
    args.referenceId = referenceId
4600 varun.gupt 5026 
    args.serviceTax = serviceTax
5027 
    args.otherCharges = otherCharges
5028 
    args.netCollection = netCollection
5029 
    args.write(self._oprot)
5030 
    self._oprot.writeMessageEnd()
5031 
    self._oprot.trans.flush()
5032 
 
5033 
  def recv_savePaymentSettlements(self, ):
5034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5035 
    if mtype == TMessageType.EXCEPTION:
5036 
      x = TApplicationException()
5037 
      x.read(self._iprot)
5038 
      self._iprot.readMessageEnd()
5039 
      raise x
5040 
    result = savePaymentSettlements_result()
5041 
    result.read(self._iprot)
5042 
    self._iprot.readMessageEnd()
5043 
    if result.ex is not None:
5044 
      raise result.ex
5045 
    return
5046 
 
5047 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5048 
    """
5049 
    Parameters:
5050 
     - settlementId
5051 
     - settlementDate
5052 
     - transactionDateFrom
5053 
     - transactionDateTo
5054 
     - amount
5055 
    """
5056 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5057 
    self.recv_saveEBSSettlementSummary()
5058 
 
5059 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5060 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5061 
    args = saveEBSSettlementSummary_args()
5062 
    args.settlementId = settlementId
5063 
    args.settlementDate = settlementDate
5064 
    args.transactionDateFrom = transactionDateFrom
5065 
    args.transactionDateTo = transactionDateTo
5066 
    args.amount = amount
5067 
    args.write(self._oprot)
5068 
    self._oprot.writeMessageEnd()
5069 
    self._oprot.trans.flush()
5070 
 
5071 
  def recv_saveEBSSettlementSummary(self, ):
5072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5073 
    if mtype == TMessageType.EXCEPTION:
5074 
      x = TApplicationException()
5075 
      x.read(self._iprot)
5076 
      self._iprot.readMessageEnd()
5077 
      raise x
5078 
    result = saveEBSSettlementSummary_result()
5079 
    result.read(self._iprot)
5080 
    self._iprot.readMessageEnd()
5081 
    if result.ex is not None:
5082 
      raise result.ex
5083 
    return
5084 
 
5386 phani.kuma 5085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5086 
    """
5087 
    Parameters:
5189 varun.gupt 5088 
     - referenceId
5089 
     - isRefund
4600 varun.gupt 5090 
    """
5386 phani.kuma 5091 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5092 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5093 
 
5386 phani.kuma 5094 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5095 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5096 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5097 
    args.referenceId = referenceId
5098 
    args.isRefund = isRefund
4600 varun.gupt 5099 
    args.write(self._oprot)
5100 
    self._oprot.writeMessageEnd()
5101 
    self._oprot.trans.flush()
5102 
 
5386 phani.kuma 5103 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5105 
    if mtype == TMessageType.EXCEPTION:
5106 
      x = TApplicationException()
5107 
      x.read(self._iprot)
5108 
      self._iprot.readMessageEnd()
5109 
      raise x
5386 phani.kuma 5110 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5111 
    result.read(self._iprot)
5112 
    self._iprot.readMessageEnd()
5113 
    if result.success is not None:
5114 
      return result.success
5115 
    if result.ex is not None:
5116 
      raise result.ex
5386 phani.kuma 5117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5118 
 
5386 phani.kuma 5119 
  def getSettlementForCod(self, orderId, isRefund):
5120 
    """
5121 
    Parameters:
5122 
     - orderId
5123 
     - isRefund
5124 
    """
5125 
    self.send_getSettlementForCod(orderId, isRefund)
5126 
    return self.recv_getSettlementForCod()
5127 
 
5128 
  def send_getSettlementForCod(self, orderId, isRefund):
5129 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5130 
    args = getSettlementForCod_args()
5131 
    args.orderId = orderId
5132 
    args.isRefund = isRefund
5133 
    args.write(self._oprot)
5134 
    self._oprot.writeMessageEnd()
5135 
    self._oprot.trans.flush()
5136 
 
5137 
  def recv_getSettlementForCod(self, ):
5138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5139 
    if mtype == TMessageType.EXCEPTION:
5140 
      x = TApplicationException()
5141 
      x.read(self._iprot)
5142 
      self._iprot.readMessageEnd()
5143 
      raise x
5144 
    result = getSettlementForCod_result()
5145 
    result.read(self._iprot)
5146 
    self._iprot.readMessageEnd()
5147 
    if result.success is not None:
5148 
      return result.success
5149 
    if result.ex is not None:
5150 
      raise result.ex
5151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5152 
 
4600 varun.gupt 5153 
  def getEBSSettlementSummaries(self, ):
5154 
    self.send_getEBSSettlementSummaries()
5155 
    return self.recv_getEBSSettlementSummaries()
5156 
 
5157 
  def send_getEBSSettlementSummaries(self, ):
5158 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5159 
    args = getEBSSettlementSummaries_args()
5160 
    args.write(self._oprot)
5161 
    self._oprot.writeMessageEnd()
5162 
    self._oprot.trans.flush()
5163 
 
5164 
  def recv_getEBSSettlementSummaries(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 = getEBSSettlementSummaries_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, "getEBSSettlementSummaries failed: unknown result");
5179 
 
5180 
  def markEBSSettlementUploaded(self, settlementId):
5181 
    """
5182 
    Parameters:
5183 
     - settlementId
5184 
    """
5185 
    self.send_markEBSSettlementUploaded(settlementId)
5186 
    self.recv_markEBSSettlementUploaded()
5187 
 
5188 
  def send_markEBSSettlementUploaded(self, settlementId):
5189 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5190 
    args = markEBSSettlementUploaded_args()
5191 
    args.settlementId = settlementId
5192 
    args.write(self._oprot)
5193 
    self._oprot.writeMessageEnd()
5194 
    self._oprot.trans.flush()
5195 
 
5196 
  def recv_markEBSSettlementUploaded(self, ):
5197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5198 
    if mtype == TMessageType.EXCEPTION:
5199 
      x = TApplicationException()
5200 
      x.read(self._iprot)
5201 
      self._iprot.readMessageEnd()
5202 
      raise x
5203 
    result = markEBSSettlementUploaded_result()
5204 
    result.read(self._iprot)
5205 
    self._iprot.readMessageEnd()
5206 
    if result.ex is not None:
5207 
      raise result.ex
5208 
    return
5209 
 
5210 
  def getEBSSettlementDate(self, settlementId):
5211 
    """
5212 
    Parameters:
5213 
     - settlementId
5214 
    """
5215 
    self.send_getEBSSettlementDate(settlementId)
5216 
    return self.recv_getEBSSettlementDate()
5217 
 
5218 
  def send_getEBSSettlementDate(self, settlementId):
5219 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5220 
    args = getEBSSettlementDate_args()
5221 
    args.settlementId = settlementId
5222 
    args.write(self._oprot)
5223 
    self._oprot.writeMessageEnd()
5224 
    self._oprot.trans.flush()
5225 
 
5226 
  def recv_getEBSSettlementDate(self, ):
5227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5228 
    if mtype == TMessageType.EXCEPTION:
5229 
      x = TApplicationException()
5230 
      x.read(self._iprot)
5231 
      self._iprot.readMessageEnd()
5232 
      raise x
5233 
    result = getEBSSettlementDate_result()
5234 
    result.read(self._iprot)
5235 
    self._iprot.readMessageEnd()
5236 
    if result.success is not None:
5237 
      return result.success
5238 
    if result.ex is not None:
5239 
      raise result.ex
5240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5241 
 
4715 varun.gupt 5242 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5243 
    """
5244 
    Parameters:
5245 
     - settlementDateFrom
5246 
     - settlementDateTo
5247 
     - isRefund
5248 
    """
5249 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5250 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5251 
 
4715 varun.gupt 5252 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5253 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5254 
    args = getSettlementsByDate_args()
5255 
    args.settlementDateFrom = settlementDateFrom
5256 
    args.settlementDateTo = settlementDateTo
5257 
    args.isRefund = isRefund
5258 
    args.write(self._oprot)
5259 
    self._oprot.writeMessageEnd()
5260 
    self._oprot.trans.flush()
5261 
 
5262 
  def recv_getSettlementsByDate(self, ):
5263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5264 
    if mtype == TMessageType.EXCEPTION:
5265 
      x = TApplicationException()
5266 
      x.read(self._iprot)
5267 
      self._iprot.readMessageEnd()
5268 
      raise x
5269 
    result = getSettlementsByDate_result()
5270 
    result.read(self._iprot)
5271 
    self._iprot.readMessageEnd()
5272 
    if result.success is not None:
5273 
      return result.success
5274 
    if result.ex is not None:
5275 
      raise result.ex
5276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5277 
 
5278 
  def getReshippedOrderIds(self, orderIds):
5279 
    """
5280 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5281 
 
5282 
    Parameters:
5283 
     - orderIds
5284 
    """
5285 
    self.send_getReshippedOrderIds(orderIds)
5286 
    return self.recv_getReshippedOrderIds()
5287 
 
5288 
  def send_getReshippedOrderIds(self, orderIds):
5289 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5290 
    args = getReshippedOrderIds_args()
5291 
    args.orderIds = orderIds
5292 
    args.write(self._oprot)
5293 
    self._oprot.writeMessageEnd()
5294 
    self._oprot.trans.flush()
5295 
 
5296 
  def recv_getReshippedOrderIds(self, ):
5297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5298 
    if mtype == TMessageType.EXCEPTION:
5299 
      x = TApplicationException()
5300 
      x.read(self._iprot)
5301 
      self._iprot.readMessageEnd()
5302 
      raise x
5303 
    result = getReshippedOrderIds_result()
5304 
    result.read(self._iprot)
5305 
    self._iprot.readMessageEnd()
5306 
    if result.success is not None:
5307 
      return result.success
5308 
    if result.ex is not None:
5309 
      raise result.ex
5310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5311 
 
5481 phani.kuma 5312 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5313 
    """
5314 
    Parameters:
5315 
     - vendorId
5481 phani.kuma 5316 
     - onlyVendorNotPaid
5317 
     - billingDateFrom
5318 
     - billingDateTo
4875 varun.gupt 5319 
    """
5481 phani.kuma 5320 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5321 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5322 
 
5481 phani.kuma 5323 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5324 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5325 
    args = getBilledOrders_args()
4875 varun.gupt 5326 
    args.vendorId = vendorId
5481 phani.kuma 5327 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5328 
    args.billingDateFrom = billingDateFrom
5329 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5330 
    args.write(self._oprot)
5331 
    self._oprot.writeMessageEnd()
5332 
    self._oprot.trans.flush()
5333 
 
5481 phani.kuma 5334 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5336 
    if mtype == TMessageType.EXCEPTION:
5337 
      x = TApplicationException()
5338 
      x.read(self._iprot)
5339 
      self._iprot.readMessageEnd()
5340 
      raise x
5481 phani.kuma 5341 
    result = getBilledOrders_result()
4875 varun.gupt 5342 
    result.read(self._iprot)
5343 
    self._iprot.readMessageEnd()
5344 
    if result.success is not None:
5345 
      return result.success
5346 
    if result.ex is not None:
5347 
      raise result.ex
5481 phani.kuma 5348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5349 
 
5031 varun.gupt 5350 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5351 
    """
5352 
    Parameters:
5353 
     - startDate
5354 
     - endDate
5355 
    """
5356 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5357 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5358 
 
5031 varun.gupt 5359 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5360 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5361 
    args = getStatusDistributionOfOrders_args()
5362 
    args.startDate = startDate
5363 
    args.endDate = endDate
5364 
    args.write(self._oprot)
5365 
    self._oprot.writeMessageEnd()
5366 
    self._oprot.trans.flush()
5367 
 
5368 
  def recv_getStatusDistributionOfOrders(self, ):
5369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5370 
    if mtype == TMessageType.EXCEPTION:
5371 
      x = TApplicationException()
5372 
      x.read(self._iprot)
5373 
      self._iprot.readMessageEnd()
5374 
      raise x
5375 
    result = getStatusDistributionOfOrders_result()
5376 
    result.read(self._iprot)
5377 
    self._iprot.readMessageEnd()
5378 
    if result.success is not None:
5379 
      return result.success
5380 
    if result.ex is not None:
5381 
      raise result.ex
5382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5383 
 
5067 varun.gupt 5384 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5385 
    """
5386 
    Parameters:
5387 
     - status
5388 
     - startDatetime
5389 
     - endDatetime
5390 
    """
5391 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5392 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5393 
 
5067 varun.gupt 5394 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5395 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5396 
    args = getOrderIdsForStatus_args()
5397 
    args.status = status
5398 
    args.startDatetime = startDatetime
5399 
    args.endDatetime = endDatetime
5400 
    args.write(self._oprot)
5401 
    self._oprot.writeMessageEnd()
5402 
    self._oprot.trans.flush()
5403 
 
5404 
  def recv_getOrderIdsForStatus(self, ):
5405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5406 
    if mtype == TMessageType.EXCEPTION:
5407 
      x = TApplicationException()
5408 
      x.read(self._iprot)
5409 
      self._iprot.readMessageEnd()
5410 
      raise x
5411 
    result = getOrderIdsForStatus_result()
5412 
    result.read(self._iprot)
5413 
    self._iprot.readMessageEnd()
5414 
    if result.success is not None:
5415 
      return result.success
5416 
    if result.ex is not None:
5417 
      raise result.ex
5418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5419 
 
5348 anupam.sin 5420 
  def updateCODAgent(self, agent, orderId):
5421 
    """
5422 
    Updates the agent who handled the COD verification call
5423 
 
5424 
    Parameters:
5425 
     - agent
5426 
     - orderId
5427 
    """
5428 
    self.send_updateCODAgent(agent, orderId)
5429 
    self.recv_updateCODAgent()
5430 
 
5431 
  def send_updateCODAgent(self, agent, orderId):
5432 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5433 
    args = updateCODAgent_args()
5434 
    args.agent = agent
5435 
    args.orderId = orderId
5436 
    args.write(self._oprot)
5437 
    self._oprot.writeMessageEnd()
5438 
    self._oprot.trans.flush()
5439 
 
5440 
  def recv_updateCODAgent(self, ):
5441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5442 
    if mtype == TMessageType.EXCEPTION:
5443 
      x = TApplicationException()
5444 
      x.read(self._iprot)
5445 
      self._iprot.readMessageEnd()
5446 
      raise x
5447 
    result = updateCODAgent_result()
5448 
    result.read(self._iprot)
5449 
    self._iprot.readMessageEnd()
5450 
    if result.ex is not None:
5451 
      raise result.ex
5452 
    return
5453 
 
5099 varun.gupt 5454 
  def updateOrderAsPaidToVendor(self, orderId):
5455 
    """
5456 
    Parameters:
5457 
     - orderId
5458 
    """
5459 
    self.send_updateOrderAsPaidToVendor(orderId)
5460 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5461 
 
5099 varun.gupt 5462 
  def send_updateOrderAsPaidToVendor(self, orderId):
5463 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5464 
    args = updateOrderAsPaidToVendor_args()
5465 
    args.orderId = orderId
5466 
    args.write(self._oprot)
5467 
    self._oprot.writeMessageEnd()
5468 
    self._oprot.trans.flush()
5469 
 
5470 
  def recv_updateOrderAsPaidToVendor(self, ):
5471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5472 
    if mtype == TMessageType.EXCEPTION:
5473 
      x = TApplicationException()
5474 
      x.read(self._iprot)
5475 
      self._iprot.readMessageEnd()
5476 
      raise x
5477 
    result = updateOrderAsPaidToVendor_result()
5478 
    result.read(self._iprot)
5479 
    self._iprot.readMessageEnd()
5480 
    if result.ex is not None:
5481 
      raise result.ex
5482 
    return
5483 
 
5386 phani.kuma 5484 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5485 
    """
5486 
    Parameters:
5487 
     - orderId
5488 
    """
5489 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5490 
    self.recv_updateOrderOnlyAsPaidToVendor()
5491 
 
5492 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5493 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5494 
    args = updateOrderOnlyAsPaidToVendor_args()
5495 
    args.orderId = orderId
5496 
    args.write(self._oprot)
5497 
    self._oprot.writeMessageEnd()
5498 
    self._oprot.trans.flush()
5499 
 
5500 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5502 
    if mtype == TMessageType.EXCEPTION:
5503 
      x = TApplicationException()
5504 
      x.read(self._iprot)
5505 
      self._iprot.readMessageEnd()
5506 
      raise x
5507 
    result = updateOrderOnlyAsPaidToVendor_result()
5508 
    result.read(self._iprot)
5509 
    self._iprot.readMessageEnd()
5510 
    if result.ex is not None:
5511 
      raise result.ex
5512 
    return
5513 
 
5208 varun.gupt 5514 
  def getRefundedOrdersMarkedPaid(self, ):
5515 
    self.send_getRefundedOrdersMarkedPaid()
5516 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5517 
 
5208 varun.gupt 5518 
  def send_getRefundedOrdersMarkedPaid(self, ):
5519 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5520 
    args = getRefundedOrdersMarkedPaid_args()
5521 
    args.write(self._oprot)
5522 
    self._oprot.writeMessageEnd()
5523 
    self._oprot.trans.flush()
5524 
 
5525 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5527 
    if mtype == TMessageType.EXCEPTION:
5528 
      x = TApplicationException()
5529 
      x.read(self._iprot)
5530 
      self._iprot.readMessageEnd()
5531 
      raise x
5532 
    result = getRefundedOrdersMarkedPaid_result()
5533 
    result.read(self._iprot)
5534 
    self._iprot.readMessageEnd()
5535 
    if result.success is not None:
5536 
      return result.success
5537 
    if result.ex is not None:
5538 
      raise result.ex
5539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5540 
 
5447 anupam.sin 5541 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5542 
    """
5543 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5544 
 
5447 anupam.sin 5545 
 
5546 
    Parameters:
5547 
     - minOrderId
5548 
     - maxOrderId
5549 
    """
5550 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5551 
    return self.recv_getAllVerificationAgents()
5552 
 
5553 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5554 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5555 
    args = getAllVerificationAgents_args()
5556 
    args.minOrderId = minOrderId
5557 
    args.maxOrderId = maxOrderId
5558 
    args.write(self._oprot)
5559 
    self._oprot.writeMessageEnd()
5560 
    self._oprot.trans.flush()
5561 
 
5562 
  def recv_getAllVerificationAgents(self, ):
5563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5564 
    if mtype == TMessageType.EXCEPTION:
5565 
      x = TApplicationException()
5566 
      x.read(self._iprot)
5567 
      self._iprot.readMessageEnd()
5568 
      raise x
5569 
    result = getAllVerificationAgents_result()
5570 
    result.read(self._iprot)
5571 
    self._iprot.readMessageEnd()
5572 
    if result.success is not None:
5573 
      return result.success
5574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5575 
 
5527 anupam.sin 5576 
  def getAllAttributesForOrderId(self, orderId):
5577 
    """
5578 
    gets all attributes for a given orderId
5447 anupam.sin 5579 
 
5527 anupam.sin 5580 
    Parameters:
5581 
     - orderId
5582 
    """
5583 
    self.send_getAllAttributesForOrderId(orderId)
5584 
    return self.recv_getAllAttributesForOrderId()
5585 
 
5586 
  def send_getAllAttributesForOrderId(self, orderId):
5587 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5588 
    args = getAllAttributesForOrderId_args()
5589 
    args.orderId = orderId
5590 
    args.write(self._oprot)
5591 
    self._oprot.writeMessageEnd()
5592 
    self._oprot.trans.flush()
5593 
 
5594 
  def recv_getAllAttributesForOrderId(self, ):
5595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5596 
    if mtype == TMessageType.EXCEPTION:
5597 
      x = TApplicationException()
5598 
      x.read(self._iprot)
5599 
      self._iprot.readMessageEnd()
5600 
      raise x
5601 
    result = getAllAttributesForOrderId_result()
5602 
    result.read(self._iprot)
5603 
    self._iprot.readMessageEnd()
5604 
    if result.success is not None:
5605 
      return result.success
5606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5607 
 
5676 rajveer 5608 
  def setOrderAttributes(self, orderId, attributes):
5609 
    """
5610 
    sets attributes for an order
5611 
 
5612 
    Parameters:
5613 
     - orderId
5614 
     - attributes
5615 
    """
5616 
    self.send_setOrderAttributes(orderId, attributes)
5617 
    self.recv_setOrderAttributes()
5618 
 
5619 
  def send_setOrderAttributes(self, orderId, attributes):
5620 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5621 
    args = setOrderAttributes_args()
5622 
    args.orderId = orderId
5623 
    args.attributes = attributes
5624 
    args.write(self._oprot)
5625 
    self._oprot.writeMessageEnd()
5626 
    self._oprot.trans.flush()
5627 
 
5628 
  def recv_setOrderAttributes(self, ):
5629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5630 
    if mtype == TMessageType.EXCEPTION:
5631 
      x = TApplicationException()
5632 
      x.read(self._iprot)
5633 
      self._iprot.readMessageEnd()
5634 
      raise x
5635 
    result = setOrderAttributes_result()
5636 
    result.read(self._iprot)
5637 
    self._iprot.readMessageEnd()
5638 
    return
5639 
 
5527 anupam.sin 5640 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5641 
    """
5642 
    sets attributes for all orders in a transaction
5643 
 
5644 
    Parameters:
5645 
     - transactionId
5646 
     - attribute
5647 
    """
5648 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5649 
    self.recv_setOrderAttributeForTransaction()
5650 
 
5651 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5652 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5653 
    args = setOrderAttributeForTransaction_args()
5654 
    args.transactionId = transactionId
5655 
    args.attribute = attribute
5656 
    args.write(self._oprot)
5657 
    self._oprot.writeMessageEnd()
5658 
    self._oprot.trans.flush()
5659 
 
5660 
  def recv_setOrderAttributeForTransaction(self, ):
5661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5662 
    if mtype == TMessageType.EXCEPTION:
5663 
      x = TApplicationException()
5664 
      x.read(self._iprot)
5665 
      self._iprot.readMessageEnd()
5666 
      raise x
5667 
    result = setOrderAttributeForTransaction_result()
5668 
    result.read(self._iprot)
5669 
    self._iprot.readMessageEnd()
5670 
    return
5671 
 
5553 rajveer 5672 
  def getReceivePendingOrders(self, storeId):
5673 
    """
5674 
    Parameters:
5675 
     - storeId
5676 
    """
5677 
    self.send_getReceivePendingOrders(storeId)
5678 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5679 
 
5553 rajveer 5680 
  def send_getReceivePendingOrders(self, storeId):
5681 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5682 
    args = getReceivePendingOrders_args()
5683 
    args.storeId = storeId
5684 
    args.write(self._oprot)
5685 
    self._oprot.writeMessageEnd()
5686 
    self._oprot.trans.flush()
5687 
 
5688 
  def recv_getReceivePendingOrders(self, ):
5689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5690 
    if mtype == TMessageType.EXCEPTION:
5691 
      x = TApplicationException()
5692 
      x.read(self._iprot)
5693 
      self._iprot.readMessageEnd()
5694 
      raise x
5695 
    result = getReceivePendingOrders_result()
5696 
    result.read(self._iprot)
5697 
    self._iprot.readMessageEnd()
5698 
    if result.success is not None:
5699 
      return result.success
5700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5701 
 
5702 
  def getReceivedAtStoreOrders(self, storeId):
5703 
    """
5704 
    Parameters:
5705 
     - storeId
5706 
    """
5707 
    self.send_getReceivedAtStoreOrders(storeId)
5708 
    return self.recv_getReceivedAtStoreOrders()
5709 
 
5710 
  def send_getReceivedAtStoreOrders(self, storeId):
5711 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5712 
    args = getReceivedAtStoreOrders_args()
5713 
    args.storeId = storeId
5714 
    args.write(self._oprot)
5715 
    self._oprot.writeMessageEnd()
5716 
    self._oprot.trans.flush()
5717 
 
5718 
  def recv_getReceivedAtStoreOrders(self, ):
5719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5720 
    if mtype == TMessageType.EXCEPTION:
5721 
      x = TApplicationException()
5722 
      x.read(self._iprot)
5723 
      self._iprot.readMessageEnd()
5724 
      raise x
5725 
    result = getReceivedAtStoreOrders_result()
5726 
    result.read(self._iprot)
5727 
    self._iprot.readMessageEnd()
5728 
    if result.success is not None:
5729 
      return result.success
5730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5731 
 
5713 rajveer 5732 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5733 
    """
5734 
    Parameters:
5735 
     - storeId
5736 
     - fromDate
5737 
     - toDate
5738 
     - onlyCod
5739 
    """
5740 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5741 
    return self.recv_getOrdersCollectionAtStore()
5742 
 
5743 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5744 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5745 
    args = getOrdersCollectionAtStore_args()
5746 
    args.storeId = storeId
5747 
    args.fromDate = fromDate
5748 
    args.toDate = toDate
5749 
    args.onlyCod = onlyCod
5750 
    args.write(self._oprot)
5751 
    self._oprot.writeMessageEnd()
5752 
    self._oprot.trans.flush()
5753 
 
5754 
  def recv_getOrdersCollectionAtStore(self, ):
5755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5756 
    if mtype == TMessageType.EXCEPTION:
5757 
      x = TApplicationException()
5758 
      x.read(self._iprot)
5759 
      self._iprot.readMessageEnd()
5760 
      raise x
5761 
    result = getOrdersCollectionAtStore_result()
5762 
    result.read(self._iprot)
5763 
    self._iprot.readMessageEnd()
5764 
    if result.success is not None:
5765 
      return result.success
5766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5767 
 
5833 rajveer 5768 
  def getOrderAttributeValue(self, orderId, attributeName):
5769 
    """
5770 
    Parameters:
5771 
     - orderId
5772 
     - attributeName
5773 
    """
5774 
    self.send_getOrderAttributeValue(orderId, attributeName)
5775 
    return self.recv_getOrderAttributeValue()
5776 
 
5777 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5778 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5779 
    args = getOrderAttributeValue_args()
5780 
    args.orderId = orderId
5781 
    args.attributeName = attributeName
5782 
    args.write(self._oprot)
5783 
    self._oprot.writeMessageEnd()
5784 
    self._oprot.trans.flush()
5785 
 
5786 
  def recv_getOrderAttributeValue(self, ):
5787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5788 
    if mtype == TMessageType.EXCEPTION:
5789 
      x = TApplicationException()
5790 
      x.read(self._iprot)
5791 
      self._iprot.readMessageEnd()
5792 
      raise x
5793 
    result = getOrderAttributeValue_result()
5794 
    result.read(self._iprot)
5795 
    self._iprot.readMessageEnd()
5796 
    if result.success is not None:
5797 
      return result.success
5798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5799 
 
6019 rajveer 5800 
  def changeJacketNumber(self, orderId, jacketNumber):
5801 
    """
5802 
    Parameters:
5803 
     - orderId
5804 
     - jacketNumber
5805 
    """
5806 
    self.send_changeJacketNumber(orderId, jacketNumber)
5807 
    return self.recv_changeJacketNumber()
5808 
 
5809 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5810 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5811 
    args = changeJacketNumber_args()
5812 
    args.orderId = orderId
5813 
    args.jacketNumber = jacketNumber
5814 
    args.write(self._oprot)
5815 
    self._oprot.writeMessageEnd()
5816 
    self._oprot.trans.flush()
5817 
 
5818 
  def recv_changeJacketNumber(self, ):
5819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5820 
    if mtype == TMessageType.EXCEPTION:
5821 
      x = TApplicationException()
5822 
      x.read(self._iprot)
5823 
      self._iprot.readMessageEnd()
5824 
      raise x
5825 
    result = changeJacketNumber_result()
5826 
    result.read(self._iprot)
5827 
    self._iprot.readMessageEnd()
5828 
    if result.success is not None:
5829 
      return result.success
5830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5831 
 
5832 
  def markOrderAsRtoInTransit(self, orderId):
5833 
    """
5834 
    Parameters:
5835 
     - orderId
5836 
    """
5837 
    self.send_markOrderAsRtoInTransit(orderId)
5838 
    return self.recv_markOrderAsRtoInTransit()
5839 
 
5840 
  def send_markOrderAsRtoInTransit(self, orderId):
5841 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5842 
    args = markOrderAsRtoInTransit_args()
5843 
    args.orderId = orderId
5844 
    args.write(self._oprot)
5845 
    self._oprot.writeMessageEnd()
5846 
    self._oprot.trans.flush()
5847 
 
5848 
  def recv_markOrderAsRtoInTransit(self, ):
5849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5850 
    if mtype == TMessageType.EXCEPTION:
5851 
      x = TApplicationException()
5852 
      x.read(self._iprot)
5853 
      self._iprot.readMessageEnd()
5854 
      raise x
5855 
    result = markOrderAsRtoInTransit_result()
5856 
    result.read(self._iprot)
5857 
    self._iprot.readMessageEnd()
5858 
    if result.success is not None:
5859 
      return result.success
5860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5861 
 
5593 mandeep.dh 5862 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5863 
    """
5864 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5865 
    invoked while scanning IN of items.
5553 rajveer 5866 
 
5593 mandeep.dh 5867 
    Parameters:
5868 
     - itemId
5869 
     - quantity
5870 
     - fulfilmentWarehouseId
5871 
     - billingWarehouseId
5872 
    """
5873 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5874 
    self.recv_acceptOrderForItem()
5875 
 
5876 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5877 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5878 
    args = acceptOrderForItem_args()
5879 
    args.itemId = itemId
5880 
    args.quantity = quantity
5881 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5882 
    args.billingWarehouseId = billingWarehouseId
5883 
    args.write(self._oprot)
5884 
    self._oprot.writeMessageEnd()
5885 
    self._oprot.trans.flush()
5886 
 
5887 
  def recv_acceptOrderForItem(self, ):
5888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5889 
    if mtype == TMessageType.EXCEPTION:
5890 
      x = TApplicationException()
5891 
      x.read(self._iprot)
5892 
      self._iprot.readMessageEnd()
5893 
      raise x
5894 
    result = acceptOrderForItem_result()
5895 
    result.read(self._iprot)
5896 
    self._iprot.readMessageEnd()
5897 
    return
5898 
 
6000 mandeep.dh 5899 
  def createRechargeOrder(self, rechargeOrder):
5900 
    """
5901 
    Parameters:
5902 
     - rechargeOrder
5903 
    """
5904 
    self.send_createRechargeOrder(rechargeOrder)
5905 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5906 
 
6000 mandeep.dh 5907 
  def send_createRechargeOrder(self, rechargeOrder):
5908 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5909 
    args = createRechargeOrder_args()
5910 
    args.rechargeOrder = rechargeOrder
5911 
    args.write(self._oprot)
5912 
    self._oprot.writeMessageEnd()
5913 
    self._oprot.trans.flush()
5914 
 
5915 
  def recv_createRechargeOrder(self, ):
5916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5917 
    if mtype == TMessageType.EXCEPTION:
5918 
      x = TApplicationException()
5919 
      x.read(self._iprot)
5920 
      self._iprot.readMessageEnd()
5921 
      raise x
5922 
    result = createRechargeOrder_result()
5923 
    result.read(self._iprot)
5924 
    self._iprot.readMessageEnd()
5925 
    if result.success is not None:
5926 
      return result.success
5927 
    if result.ex is not None:
5928 
      raise result.ex
5929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5930 
 
6031 rajveer 5931 
  def getRechargeOrder(self, rechargeRrderId):
5932 
    """
5933 
    Parameters:
5934 
     - rechargeRrderId
5935 
    """
5936 
    self.send_getRechargeOrder(rechargeRrderId)
5937 
    return self.recv_getRechargeOrder()
5938 
 
5939 
  def send_getRechargeOrder(self, rechargeRrderId):
5940 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5941 
    args = getRechargeOrder_args()
5942 
    args.rechargeRrderId = rechargeRrderId
5943 
    args.write(self._oprot)
5944 
    self._oprot.writeMessageEnd()
5945 
    self._oprot.trans.flush()
5946 
 
5947 
  def recv_getRechargeOrder(self, ):
5948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5949 
    if mtype == TMessageType.EXCEPTION:
5950 
      x = TApplicationException()
5951 
      x.read(self._iprot)
5952 
      self._iprot.readMessageEnd()
5953 
      raise x
5954 
    result = getRechargeOrder_result()
5955 
    result.read(self._iprot)
5956 
    self._iprot.readMessageEnd()
5957 
    if result.success is not None:
5958 
      return result.success
5959 
    if result.ex is not None:
5960 
      raise result.ex
5961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5962 
 
5963 
  def getRechargeOrders(self, userId):
5964 
    """
5965 
    Parameters:
5966 
     - userId
5967 
    """
5968 
    self.send_getRechargeOrders(userId)
5969 
    return self.recv_getRechargeOrders()
5970 
 
5971 
  def send_getRechargeOrders(self, userId):
5972 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5973 
    args = getRechargeOrders_args()
5974 
    args.userId = userId
5975 
    args.write(self._oprot)
5976 
    self._oprot.writeMessageEnd()
5977 
    self._oprot.trans.flush()
5978 
 
5979 
  def recv_getRechargeOrders(self, ):
5980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5981 
    if mtype == TMessageType.EXCEPTION:
5982 
      x = TApplicationException()
5983 
      x.read(self._iprot)
5984 
      self._iprot.readMessageEnd()
5985 
      raise x
5986 
    result = getRechargeOrders_result()
5987 
    result.read(self._iprot)
5988 
    self._iprot.readMessageEnd()
5989 
    if result.success is not None:
5990 
      return result.success
5991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5992 
 
6000 mandeep.dh 5993 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5994 
    """
5995 
    Parameters:
5996 
     - rechargeOrderId
5997 
     - rechargeOrderStatus
5998 
    """
5999 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6000 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6001 
 
6002 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6003 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6004 
    args = updateRechargeOrderStatus_args()
6005 
    args.rechargeOrderId = rechargeOrderId
6006 
    args.rechargeOrderStatus = rechargeOrderStatus
6007 
    args.write(self._oprot)
6008 
    self._oprot.writeMessageEnd()
6009 
    self._oprot.trans.flush()
6010 
 
6011 
  def recv_updateRechargeOrderStatus(self, ):
6012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6013 
    if mtype == TMessageType.EXCEPTION:
6014 
      x = TApplicationException()
6015 
      x.read(self._iprot)
6016 
      self._iprot.readMessageEnd()
6017 
      raise x
6018 
    result = updateRechargeOrderStatus_result()
6019 
    result.read(self._iprot)
6020 
    self._iprot.readMessageEnd()
6031 rajveer 6021 
    if result.success is not None:
6022 
      return result.success
6000 mandeep.dh 6023 
    if result.ex is not None:
6024 
      raise result.ex
6031 rajveer 6025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6026 
 
6031 rajveer 6027 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6028 
    """
6029 
    Parameters:
6031 rajveer 6030 
     - rechargeOrderId
6000 mandeep.dh 6031 
    """
6031 rajveer 6032 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6033 
    return self.recv_activateRechargeTxn()
6034 
 
6031 rajveer 6035 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6036 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6037 
    args = activateRechargeTxn_args()
6031 rajveer 6038 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6039 
    args.write(self._oprot)
6040 
    self._oprot.writeMessageEnd()
6041 
    self._oprot.trans.flush()
6042 
 
6043 
  def recv_activateRechargeTxn(self, ):
6044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6045 
    if mtype == TMessageType.EXCEPTION:
6046 
      x = TApplicationException()
6047 
      x.read(self._iprot)
6048 
      self._iprot.readMessageEnd()
6049 
      raise x
6050 
    result = activateRechargeTxn_result()
6051 
    result.read(self._iprot)
6052 
    self._iprot.readMessageEnd()
6053 
    if result.success is not None:
6054 
      return result.success
6055 
    if result.ex is not None:
6056 
      raise result.ex
6057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6058 
 
6031 rajveer 6059 
  def getUserWallet(self, userId):
6000 mandeep.dh 6060 
    """
6061 
    Parameters:
6031 rajveer 6062 
     - userId
6000 mandeep.dh 6063 
    """
6031 rajveer 6064 
    self.send_getUserWallet(userId)
6065 
    return self.recv_getUserWallet()
6000 mandeep.dh 6066 
 
6031 rajveer 6067 
  def send_getUserWallet(self, userId):
6068 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6069 
    args = getUserWallet_args()
6070 
    args.userId = userId
6000 mandeep.dh 6071 
    args.write(self._oprot)
6072 
    self._oprot.writeMessageEnd()
6073 
    self._oprot.trans.flush()
6074 
 
6031 rajveer 6075 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6077 
    if mtype == TMessageType.EXCEPTION:
6078 
      x = TApplicationException()
6079 
      x.read(self._iprot)
6080 
      self._iprot.readMessageEnd()
6081 
      raise x
6031 rajveer 6082 
    result = getUserWallet_result()
6000 mandeep.dh 6083 
    result.read(self._iprot)
6084 
    self._iprot.readMessageEnd()
6085 
    if result.success is not None:
6086 
      return result.success
6031 rajveer 6087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6088 
 
6031 rajveer 6089 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6090 
    """
6091 
    Parameters:
6031 rajveer 6092 
     - userId
6000 mandeep.dh 6093 
    """
6031 rajveer 6094 
    self.send_getUserWalletHistory(userId)
6095 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6096 
 
6031 rajveer 6097 
  def send_getUserWalletHistory(self, userId):
6098 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6099 
    args = getUserWalletHistory_args()
6100 
    args.userId = userId
6000 mandeep.dh 6101 
    args.write(self._oprot)
6102 
    self._oprot.writeMessageEnd()
6103 
    self._oprot.trans.flush()
6104 
 
6031 rajveer 6105 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6107 
    if mtype == TMessageType.EXCEPTION:
6108 
      x = TApplicationException()
6109 
      x.read(self._iprot)
6110 
      self._iprot.readMessageEnd()
6111 
      raise x
6031 rajveer 6112 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6113 
    result.read(self._iprot)
6114 
    self._iprot.readMessageEnd()
6115 
    if result.success is not None:
6116 
      return result.success
6031 rajveer 6117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6118 
 
6050 anupam.sin 6119 
  def getRechargeOrdersForTransaction(self, txnId):
6120 
    """
6121 
    Returns a recharge order for a given transactionId
6122 
 
6123 
    Parameters:
6124 
     - txnId
6125 
    """
6126 
    self.send_getRechargeOrdersForTransaction(txnId)
6127 
    return self.recv_getRechargeOrdersForTransaction()
6128 
 
6129 
  def send_getRechargeOrdersForTransaction(self, txnId):
6130 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6131 
    args = getRechargeOrdersForTransaction_args()
6132 
    args.txnId = txnId
6133 
    args.write(self._oprot)
6134 
    self._oprot.writeMessageEnd()
6135 
    self._oprot.trans.flush()
6136 
 
6137 
  def recv_getRechargeOrdersForTransaction(self, ):
6138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6139 
    if mtype == TMessageType.EXCEPTION:
6140 
      x = TApplicationException()
6141 
      x.read(self._iprot)
6142 
      self._iprot.readMessageEnd()
6143 
      raise x
6144 
    result = getRechargeOrdersForTransaction_result()
6145 
    result.read(self._iprot)
6146 
    self._iprot.readMessageEnd()
6147 
    if result.success is not None:
6148 
      return result.success
6149 
    if result.ex is not None:
6150 
      raise result.ex
6151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6152 
 
6206 rajveer 6153 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6154 
    """
6155 
    Parameters:
6156 
     - rechargeType
6206 rajveer 6157 
     - onlyActive
6048 rajveer 6158 
    """
6206 rajveer 6159 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6160 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6161 
 
6206 rajveer 6162 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6163 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6164 
    args = getServiceProviders_args()
6165 
    args.rechargeType = rechargeType
6206 rajveer 6166 
    args.onlyActive = onlyActive
6048 rajveer 6167 
    args.write(self._oprot)
6168 
    self._oprot.writeMessageEnd()
6169 
    self._oprot.trans.flush()
6170 
 
6171 
  def recv_getServiceProviders(self, ):
6172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6173 
    if mtype == TMessageType.EXCEPTION:
6174 
      x = TApplicationException()
6175 
      x.read(self._iprot)
6176 
      self._iprot.readMessageEnd()
6177 
      raise x
6178 
    result = getServiceProviders_result()
6179 
    result.read(self._iprot)
6180 
    self._iprot.readMessageEnd()
6181 
    if result.success is not None:
6182 
      return result.success
6183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6184 
 
6049 rajveer 6185 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6186 
    """
6187 
    Parameters:
6049 rajveer 6188 
     - rechargeType
6048 rajveer 6189 
     - deviceNumber
6190 
    """
6049 rajveer 6191 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6192 
    return self.recv_getServiceProviderForDevice()
6193 
 
6049 rajveer 6194 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6195 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6196 
    args = getServiceProviderForDevice_args()
6049 rajveer 6197 
    args.rechargeType = rechargeType
6048 rajveer 6198 
    args.deviceNumber = deviceNumber
6199 
    args.write(self._oprot)
6200 
    self._oprot.writeMessageEnd()
6201 
    self._oprot.trans.flush()
6202 
 
6203 
  def recv_getServiceProviderForDevice(self, ):
6204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6205 
    if mtype == TMessageType.EXCEPTION:
6206 
      x = TApplicationException()
6207 
      x.read(self._iprot)
6208 
      self._iprot.readMessageEnd()
6209 
      raise x
6210 
    result = getServiceProviderForDevice_result()
6211 
    result.read(self._iprot)
6212 
    self._iprot.readMessageEnd()
6213 
    if result.success is not None:
6214 
      return result.success
6215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6216 
 
6591 anupam.sin 6217 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6218 
    """
6219 
    Parameters:
6220 
     - rechargeType
6221 
     - deviceNumber
6307 anupam.sin 6222 
     - userSelectedProviderId
6591 anupam.sin 6223 
     - clientAddress
6269 rajveer 6224 
    """
6591 anupam.sin 6225 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6226 
    return self.recv_validateRecharge()
6227 
 
6591 anupam.sin 6228 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6229 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6230 
    args = validateRecharge_args()
6231 
    args.rechargeType = rechargeType
6232 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6233 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6234 
    args.clientAddress = clientAddress
6269 rajveer 6235 
    args.write(self._oprot)
6236 
    self._oprot.writeMessageEnd()
6237 
    self._oprot.trans.flush()
6238 
 
6239 
  def recv_validateRecharge(self, ):
6240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6241 
    if mtype == TMessageType.EXCEPTION:
6242 
      x = TApplicationException()
6243 
      x.read(self._iprot)
6244 
      self._iprot.readMessageEnd()
6245 
      raise x
6246 
    result = validateRecharge_result()
6247 
    result.read(self._iprot)
6248 
    self._iprot.readMessageEnd()
6249 
    if result.success is not None:
6250 
      return result.success
6251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6252 
 
6094 rajveer 6253 
  def getRechargeOrdersForDevice(self, deviceNumber):
6254 
    """
6255 
    Parameters:
6256 
     - deviceNumber
6257 
    """
6258 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6259 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6260 
 
6094 rajveer 6261 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6262 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6263 
    args = getRechargeOrdersForDevice_args()
6264 
    args.deviceNumber = deviceNumber
6265 
    args.write(self._oprot)
6266 
    self._oprot.writeMessageEnd()
6267 
    self._oprot.trans.flush()
6268 
 
6269 
  def recv_getRechargeOrdersForDevice(self, ):
6270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6271 
    if mtype == TMessageType.EXCEPTION:
6272 
      x = TApplicationException()
6273 
      x.read(self._iprot)
6274 
      self._iprot.readMessageEnd()
6275 
      raise x
6276 
    result = getRechargeOrdersForDevice_result()
6277 
    result.read(self._iprot)
6278 
    self._iprot.readMessageEnd()
6279 
    if result.success is not None:
6280 
      return result.success
6281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6282 
 
6283 
  def addAmountToWallet(self, userId, orderId, amount):
6284 
    """
6285 
    Parameters:
6286 
     - userId
6287 
     - orderId
6288 
     - amount
6289 
    """
6290 
    self.send_addAmountToWallet(userId, orderId, amount)
6291 
    self.recv_addAmountToWallet()
6292 
 
6293 
  def send_addAmountToWallet(self, userId, orderId, amount):
6294 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6295 
    args = addAmountToWallet_args()
6296 
    args.userId = userId
6297 
    args.orderId = orderId
6298 
    args.amount = amount
6299 
    args.write(self._oprot)
6300 
    self._oprot.writeMessageEnd()
6301 
    self._oprot.trans.flush()
6302 
 
6303 
  def recv_addAmountToWallet(self, ):
6304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6305 
    if mtype == TMessageType.EXCEPTION:
6306 
      x = TApplicationException()
6307 
      x.read(self._iprot)
6308 
      self._iprot.readMessageEnd()
6309 
      raise x
6310 
    result = addAmountToWallet_result()
6311 
    result.read(self._iprot)
6312 
    self._iprot.readMessageEnd()
6313 
    return
6314 
 
6188 rajveer 6315 
  def getRechargeStatistics(self, ):
6316 
    self.send_getRechargeStatistics()
6317 
    return self.recv_getRechargeStatistics()
6318 
 
6319 
  def send_getRechargeStatistics(self, ):
6320 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6321 
    args = getRechargeStatistics_args()
6322 
    args.write(self._oprot)
6323 
    self._oprot.writeMessageEnd()
6324 
    self._oprot.trans.flush()
6325 
 
6326 
  def recv_getRechargeStatistics(self, ):
6327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6328 
    if mtype == TMessageType.EXCEPTION:
6329 
      x = TApplicationException()
6330 
      x.read(self._iprot)
6331 
      self._iprot.readMessageEnd()
6332 
      raise x
6333 
    result = getRechargeStatistics_result()
6334 
    result.read(self._iprot)
6335 
    self._iprot.readMessageEnd()
6336 
    if result.success is not None:
6337 
      return result.success
6338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6339 
 
6154 rajveer 6340 
  def getRechargeOrdersForStatus(self, status):
6341 
    """
6342 
    Parameters:
6343 
     - status
6344 
    """
6345 
    self.send_getRechargeOrdersForStatus(status)
6346 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6347 
 
6154 rajveer 6348 
  def send_getRechargeOrdersForStatus(self, status):
6349 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6350 
    args = getRechargeOrdersForStatus_args()
6351 
    args.status = status
6352 
    args.write(self._oprot)
6353 
    self._oprot.writeMessageEnd()
6354 
    self._oprot.trans.flush()
6355 
 
6356 
  def recv_getRechargeOrdersForStatus(self, ):
6357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6358 
    if mtype == TMessageType.EXCEPTION:
6359 
      x = TApplicationException()
6360 
      x.read(self._iprot)
6361 
      self._iprot.readMessageEnd()
6362 
      raise x
6363 
    result = getRechargeOrdersForStatus_result()
6364 
    result.read(self._iprot)
6365 
    self._iprot.readMessageEnd()
6366 
    if result.success is not None:
6367 
      return result.success
6368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6369 
 
6159 rajveer 6370 
  def getPlansForOperator(self, operatorId):
6371 
    """
6372 
    Parameters:
6373 
     - operatorId
6374 
    """
6375 
    self.send_getPlansForOperator(operatorId)
6376 
    return self.recv_getPlansForOperator()
6154 rajveer 6377 
 
6159 rajveer 6378 
  def send_getPlansForOperator(self, operatorId):
6379 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6380 
    args = getPlansForOperator_args()
6381 
    args.operatorId = operatorId
6382 
    args.write(self._oprot)
6383 
    self._oprot.writeMessageEnd()
6384 
    self._oprot.trans.flush()
6385 
 
6386 
  def recv_getPlansForOperator(self, ):
6387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6388 
    if mtype == TMessageType.EXCEPTION:
6389 
      x = TApplicationException()
6390 
      x.read(self._iprot)
6391 
      self._iprot.readMessageEnd()
6392 
      raise x
6393 
    result = getPlansForOperator_result()
6394 
    result.read(self._iprot)
6395 
    self._iprot.readMessageEnd()
6396 
    if result.success is not None:
6397 
      return result.success
6398 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6399 
 
6307 anupam.sin 6400 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6401 
    """
6402 
    Returns denominations for a given operator and circle
6159 rajveer 6403 
 
6289 anupam.sin 6404 
    Parameters:
6405 
     - operatorId
6307 anupam.sin 6406 
     - circleCode
6289 anupam.sin 6407 
     - denominationType
6408 
    """
6307 anupam.sin 6409 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6410 
    return self.recv_getRechargeDenominations()
6411 
 
6307 anupam.sin 6412 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6413 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6414 
    args = getRechargeDenominations_args()
6415 
    args.operatorId = operatorId
6307 anupam.sin 6416 
    args.circleCode = circleCode
6289 anupam.sin 6417 
    args.denominationType = denominationType
6418 
    args.write(self._oprot)
6419 
    self._oprot.writeMessageEnd()
6420 
    self._oprot.trans.flush()
6421 
 
6422 
  def recv_getRechargeDenominations(self, ):
6423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6424 
    if mtype == TMessageType.EXCEPTION:
6425 
      x = TApplicationException()
6426 
      x.read(self._iprot)
6427 
      self._iprot.readMessageEnd()
6428 
      raise x
6429 
    result = getRechargeDenominations_result()
6430 
    result.read(self._iprot)
6431 
    self._iprot.readMessageEnd()
6432 
    if result.success is not None:
6433 
      return result.success
6434 
    if result.ex is not None:
6435 
      raise result.ex
6436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6437 
 
6371 rajveer 6438 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6439 
    """
6440 
    Parameters:
6441 
     - operatorId
6442 
     - circleId
6443 
     - isAvailable
6444 
    """
6445 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6446 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6447 
 
6371 rajveer 6448 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6449 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6450 
    args = updateAvailabilityStatus_args()
6451 
    args.operatorId = operatorId
6452 
    args.circleId = circleId
6453 
    args.isAvailable = isAvailable
6454 
    args.write(self._oprot)
6455 
    self._oprot.writeMessageEnd()
6456 
    self._oprot.trans.flush()
6457 
 
6458 
  def recv_updateAvailabilityStatus(self, ):
6459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6460 
    if mtype == TMessageType.EXCEPTION:
6461 
      x = TApplicationException()
6462 
      x.read(self._iprot)
6463 
      self._iprot.readMessageEnd()
6464 
      raise x
6465 
    result = updateAvailabilityStatus_result()
6466 
    result.read(self._iprot)
6467 
    self._iprot.readMessageEnd()
6468 
    return
6469 
 
6389 rajveer 6470 
  def getAvailableEmiSchemes(self, ):
6471 
    self.send_getAvailableEmiSchemes()
6472 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6473 
 
6389 rajveer 6474 
  def send_getAvailableEmiSchemes(self, ):
6475 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6476 
    args = getAvailableEmiSchemes_args()
6477 
    args.write(self._oprot)
6478 
    self._oprot.writeMessageEnd()
6479 
    self._oprot.trans.flush()
6480 
 
6481 
  def recv_getAvailableEmiSchemes(self, ):
6482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6483 
    if mtype == TMessageType.EXCEPTION:
6484 
      x = TApplicationException()
6485 
      x.read(self._iprot)
6486 
      self._iprot.readMessageEnd()
6487 
      raise x
6488 
    result = getAvailableEmiSchemes_result()
6489 
    result.read(self._iprot)
6490 
    self._iprot.readMessageEnd()
6491 
    if result.success is not None:
6492 
      return result.success
6493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6494 
 
6495 
  def getMiscCharges(self, transactionId):
6496 
    """
6497 
    Parameters:
6498 
     - transactionId
6499 
    """
6500 
    self.send_getMiscCharges(transactionId)
6501 
    return self.recv_getMiscCharges()
6502 
 
6503 
  def send_getMiscCharges(self, transactionId):
6504 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6505 
    args = getMiscCharges_args()
6506 
    args.transactionId = transactionId
6507 
    args.write(self._oprot)
6508 
    self._oprot.writeMessageEnd()
6509 
    self._oprot.trans.flush()
6510 
 
6511 
  def recv_getMiscCharges(self, ):
6512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6513 
    if mtype == TMessageType.EXCEPTION:
6514 
      x = TApplicationException()
6515 
      x.read(self._iprot)
6516 
      self._iprot.readMessageEnd()
6517 
      raise x
6518 
    result = getMiscCharges_result()
6519 
    result.read(self._iprot)
6520 
    self._iprot.readMessageEnd()
6521 
    if result.success is not None:
6522 
      return result.success
6523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6524 
 
6507 anupam.sin 6525 
  def refundRechargeOrder(self, rechargeOrderId):
6526 
    """
6527 
    Parameters:
6528 
     - rechargeOrderId
6529 
    """
6530 
    self.send_refundRechargeOrder(rechargeOrderId)
6531 
    return self.recv_refundRechargeOrder()
6389 rajveer 6532 
 
6507 anupam.sin 6533 
  def send_refundRechargeOrder(self, rechargeOrderId):
6534 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6535 
    args = refundRechargeOrder_args()
6536 
    args.rechargeOrderId = rechargeOrderId
6537 
    args.write(self._oprot)
6538 
    self._oprot.writeMessageEnd()
6539 
    self._oprot.trans.flush()
6540 
 
6541 
  def recv_refundRechargeOrder(self, ):
6542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6543 
    if mtype == TMessageType.EXCEPTION:
6544 
      x = TApplicationException()
6545 
      x.read(self._iprot)
6546 
      self._iprot.readMessageEnd()
6547 
      raise x
6548 
    result = refundRechargeOrder_result()
6549 
    result.read(self._iprot)
6550 
    self._iprot.readMessageEnd()
6551 
    if result.success is not None:
6552 
      return result.success
6553 
    if result.ex is not None:
6554 
      raise result.ex
6555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6556 
 
6821 amar.kumar 6557 
  def getPhysicalOrders(self, fromDate, toDate):
6558 
    """
6559 
    Parameters:
6560 
     - fromDate
6561 
     - toDate
6562 
    """
6563 
    self.send_getPhysicalOrders(fromDate, toDate)
6564 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6565 
 
6821 amar.kumar 6566 
  def send_getPhysicalOrders(self, fromDate, toDate):
6567 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6568 
    args = getPhysicalOrders_args()
6569 
    args.fromDate = fromDate
6570 
    args.toDate = toDate
6571 
    args.write(self._oprot)
6572 
    self._oprot.writeMessageEnd()
6573 
    self._oprot.trans.flush()
6574 
 
6575 
  def recv_getPhysicalOrders(self, ):
6576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6577 
    if mtype == TMessageType.EXCEPTION:
6578 
      x = TApplicationException()
6579 
      x.read(self._iprot)
6580 
      self._iprot.readMessageEnd()
6581 
      raise x
6582 
    result = getPhysicalOrders_result()
6583 
    result.read(self._iprot)
6584 
    self._iprot.readMessageEnd()
6585 
    if result.success is not None:
6586 
      return result.success
6587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6588 
 
6589 
 
3376 rajveer 6590 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6591 
  def __init__(self, handler):
3376 rajveer 6592 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6593 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6594 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6595 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6596 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6597 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6598 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6599 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6600 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6601 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6602 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6603 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6604 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6605 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6606 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6607 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6608 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6609 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6610 
    self._processMap["createOrder"] = Processor.process_createOrder
6611 
    self._processMap["getOrder"] = Processor.process_getOrder
6612 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6613 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6614 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6615 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6616 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6617 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6618 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6619 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6620 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6621 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6622 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6623 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6624 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6625 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6626 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6627 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6628 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6629 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6630 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6631 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6632 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6633 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6634 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6635 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6636 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6637 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6638 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6639 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6640 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6641 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6642 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6643 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6644 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6645 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6646 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6647 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6648 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6649 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6650 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6651 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6652 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6653 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6654 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6655 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6656 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6657 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6658 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6659 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6660 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6661 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6662 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6663 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6664 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6665 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6666 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6667 
    self._processMap["changeItem"] = Processor.process_changeItem
6668 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6669 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6670 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6671 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6672 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6673 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6674 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6675 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6676 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6677 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6678 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6679 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6680 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6681 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6682 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6683 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6684 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6685 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6686 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6687 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6688 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6689 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6690 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6691 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6692 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6693 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6694 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6695 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6696 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6697 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6698 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6699 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6700 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6701 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6702 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6703 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6704 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6705 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6706 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6707 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6708 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6709 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6710 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6711 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6712 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6713 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6714 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6715 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6716 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6717 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6718 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6719 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6720 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6721 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6722 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6723 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6724 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6725 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6726 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6727 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6728 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6729 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6730 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6731 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6732 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6733 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6734 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6735 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6736 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6737 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6738 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6739 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6740 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6741 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
94 ashish 6742 
 
6743 
  def process(self, iprot, oprot):
6744 
    (name, type, seqid) = iprot.readMessageBegin()
6745 
    if name not in self._processMap:
6746 
      iprot.skip(TType.STRUCT)
6747 
      iprot.readMessageEnd()
6748 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6749 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6750 
      x.write(oprot)
6751 
      oprot.writeMessageEnd()
6752 
      oprot.trans.flush()
6753 
      return
6754 
    else:
6755 
      self._processMap[name](self, seqid, iprot, oprot)
6756 
    return True
6757 
 
6758 
  def process_createTransaction(self, seqid, iprot, oprot):
6759 
    args = createTransaction_args()
6760 
    args.read(iprot)
6761 
    iprot.readMessageEnd()
6762 
    result = createTransaction_result()
6763 
    try:
132 ashish 6764 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6765 
    except TransactionServiceException, ex:
6766 
      result.ex = ex
6767 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6768 
    result.write(oprot)
6769 
    oprot.writeMessageEnd()
6770 
    oprot.trans.flush()
6771 
 
6772 
  def process_getTransaction(self, seqid, iprot, oprot):
6773 
    args = getTransaction_args()
6774 
    args.read(iprot)
6775 
    iprot.readMessageEnd()
6776 
    result = getTransaction_result()
6777 
    try:
6778 
      result.success = self._handler.getTransaction(args.id)
6779 
    except TransactionServiceException, ex:
6780 
      result.ex = ex
6781 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6782 
    result.write(oprot)
6783 
    oprot.writeMessageEnd()
6784 
    oprot.trans.flush()
6785 
 
6786 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6787 
    args = getTransactionsForCustomer_args()
6788 
    args.read(iprot)
6789 
    iprot.readMessageEnd()
6790 
    result = getTransactionsForCustomer_result()
6791 
    try:
6792 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6793 
    except TransactionServiceException, ex:
6794 
      result.ex = ex
6795 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6796 
    result.write(oprot)
6797 
    oprot.writeMessageEnd()
6798 
    oprot.trans.flush()
6799 
 
132 ashish 6800 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6801 
    args = getTransactionsForShoppingCartId_args()
6802 
    args.read(iprot)
6803 
    iprot.readMessageEnd()
6804 
    result = getTransactionsForShoppingCartId_result()
6805 
    try:
6806 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6807 
    except TransactionServiceException, ex:
6808 
      result.ex = ex
6809 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6810 
    result.write(oprot)
6811 
    oprot.writeMessageEnd()
6812 
    oprot.trans.flush()
6813 
 
94 ashish 6814 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6815 
    args = getTransactionStatus_args()
6816 
    args.read(iprot)
6817 
    iprot.readMessageEnd()
6818 
    result = getTransactionStatus_result()
6819 
    try:
6820 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6821 
    except TransactionServiceException, ex:
6822 
      result.ex = ex
6823 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6824 
    result.write(oprot)
6825 
    oprot.writeMessageEnd()
6826 
    oprot.trans.flush()
6827 
 
6828 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6829 
    args = changeTransactionStatus_args()
6830 
    args.read(iprot)
6831 
    iprot.readMessageEnd()
6832 
    result = changeTransactionStatus_result()
6833 
    try:
5527 anupam.sin 6834 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6835 
    except TransactionServiceException, ex:
6836 
      result.ex = ex
6837 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6838 
    result.write(oprot)
6839 
    oprot.writeMessageEnd()
6840 
    oprot.trans.flush()
6841 
 
1398 varun.gupt 6842 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6843 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6844 
    args.read(iprot)
6845 
    iprot.readMessageEnd()
1398 varun.gupt 6846 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6847 
    try:
1398 varun.gupt 6848 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6849 
    except TransactionServiceException, ex:
6850 
      result.ex = ex
1398 varun.gupt 6851 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6852 
    result.write(oprot)
6853 
    oprot.writeMessageEnd()
6854 
    oprot.trans.flush()
6855 
 
483 rajveer 6856 
  def process_getAllOrders(self, seqid, iprot, oprot):
6857 
    args = getAllOrders_args()
94 ashish 6858 
    args.read(iprot)
6859 
    iprot.readMessageEnd()
483 rajveer 6860 
    result = getAllOrders_result()
94 ashish 6861 
    try:
4801 anupam.sin 6862 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6863 
    except TransactionServiceException, ex:
6864 
      result.ex = ex
483 rajveer 6865 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6866 
    result.write(oprot)
6867 
    oprot.writeMessageEnd()
6868 
    oprot.trans.flush()
6869 
 
4133 chandransh 6870 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6871 
    args = getOrdersInBatch_args()
6872 
    args.read(iprot)
6873 
    iprot.readMessageEnd()
6874 
    result = getOrdersInBatch_result()
6875 
    try:
6876 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6877 
    except TransactionServiceException, ex:
6878 
      result.ex = ex
6879 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6880 
    result.write(oprot)
6881 
    oprot.writeMessageEnd()
6882 
    oprot.trans.flush()
6883 
 
6884 
  def process_getOrderCount(self, seqid, iprot, oprot):
6885 
    args = getOrderCount_args()
6886 
    args.read(iprot)
6887 
    iprot.readMessageEnd()
6888 
    result = getOrderCount_result()
6889 
    try:
6890 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6891 
    except TransactionServiceException, ex:
6892 
      result.ex = ex
6893 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6894 
    result.write(oprot)
6895 
    oprot.writeMessageEnd()
6896 
    oprot.trans.flush()
6897 
 
999 varun.gupt 6898 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6899 
    args = getOrdersByBillingDate_args()
6900 
    args.read(iprot)
6901 
    iprot.readMessageEnd()
6902 
    result = getOrdersByBillingDate_result()
6903 
    try:
6904 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6905 
    except TransactionServiceException, ex:
6906 
      result.ex = ex
6907 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6908 
    result.write(oprot)
6909 
    oprot.writeMessageEnd()
6910 
    oprot.trans.flush()
6911 
 
3427 chandransh 6912 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6913 
    args = getOrdersByShippingDate_args()
6914 
    args.read(iprot)
6915 
    iprot.readMessageEnd()
6916 
    result = getOrdersByShippingDate_result()
6917 
    try:
3451 chandransh 6918 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6919 
    except TransactionServiceException, ex:
6920 
      result.ex = ex
6921 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6922 
    result.write(oprot)
6923 
    oprot.writeMessageEnd()
6924 
    oprot.trans.flush()
6925 
 
1382 varun.gupt 6926 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6927 
    args = getReturnableOrdersForCustomer_args()
6928 
    args.read(iprot)
6929 
    iprot.readMessageEnd()
6930 
    result = getReturnableOrdersForCustomer_result()
6931 
    try:
6932 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6933 
    except TransactionServiceException, ex:
6934 
      result.ex = ex
6935 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6936 
    result.write(oprot)
6937 
    oprot.writeMessageEnd()
6938 
    oprot.trans.flush()
6939 
 
6940 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6941 
    args = getCancellableOrdersForCustomer_args()
6942 
    args.read(iprot)
6943 
    iprot.readMessageEnd()
6944 
    result = getCancellableOrdersForCustomer_result()
6945 
    try:
6946 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6947 
    except TransactionServiceException, ex:
6948 
      result.ex = ex
6949 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6950 
    result.write(oprot)
6951 
    oprot.writeMessageEnd()
6952 
    oprot.trans.flush()
6953 
 
483 rajveer 6954 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6955 
    args = changeOrderStatus_args()
94 ashish 6956 
    args.read(iprot)
6957 
    iprot.readMessageEnd()
483 rajveer 6958 
    result = changeOrderStatus_result()
94 ashish 6959 
    try:
483 rajveer 6960 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6961 
    except TransactionServiceException, ex:
6962 
      result.ex = ex
483 rajveer 6963 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6964 
    result.write(oprot)
6965 
    oprot.writeMessageEnd()
6966 
    oprot.trans.flush()
6967 
 
483 rajveer 6968 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6969 
    args = getOrdersForTransaction_args()
94 ashish 6970 
    args.read(iprot)
6971 
    iprot.readMessageEnd()
483 rajveer 6972 
    result = getOrdersForTransaction_result()
94 ashish 6973 
    try:
1528 ankur.sing 6974 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6975 
    except TransactionServiceException, ex:
6976 
      result.ex = ex
483 rajveer 6977 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6978 
    result.write(oprot)
6979 
    oprot.writeMessageEnd()
6980 
    oprot.trans.flush()
6981 
 
483 rajveer 6982 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6983 
    args = getOrdersForCustomer_args()
94 ashish 6984 
    args.read(iprot)
6985 
    iprot.readMessageEnd()
483 rajveer 6986 
    result = getOrdersForCustomer_result()
94 ashish 6987 
    try:
3014 chandransh 6988 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6989 
    except TransactionServiceException, ex:
6990 
      result.ex = ex
483 rajveer 6991 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6992 
    result.write(oprot)
6993 
    oprot.writeMessageEnd()
6994 
    oprot.trans.flush()
6995 
 
483 rajveer 6996 
  def process_createOrder(self, seqid, iprot, oprot):
6997 
    args = createOrder_args()
94 ashish 6998 
    args.read(iprot)
6999 
    iprot.readMessageEnd()
483 rajveer 7000 
    result = createOrder_result()
94 ashish 7001 
    try:
483 rajveer 7002 
      result.success = self._handler.createOrder(args.order)
94 ashish 7003 
    except TransactionServiceException, ex:
7004 
      result.ex = ex
483 rajveer 7005 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7006 
    result.write(oprot)
7007 
    oprot.writeMessageEnd()
7008 
    oprot.trans.flush()
7009 
 
483 rajveer 7010 
  def process_getOrder(self, seqid, iprot, oprot):
7011 
    args = getOrder_args()
94 ashish 7012 
    args.read(iprot)
7013 
    iprot.readMessageEnd()
483 rajveer 7014 
    result = getOrder_result()
94 ashish 7015 
    try:
483 rajveer 7016 
      result.success = self._handler.getOrder(args.id)
94 ashish 7017 
    except TransactionServiceException, ex:
7018 
      result.ex = ex
483 rajveer 7019 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7020 
    result.write(oprot)
7021 
    oprot.writeMessageEnd()
7022 
    oprot.trans.flush()
7023 
 
483 rajveer 7024 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7025 
    args = getLineItemsForOrder_args()
94 ashish 7026 
    args.read(iprot)
7027 
    iprot.readMessageEnd()
483 rajveer 7028 
    result = getLineItemsForOrder_result()
94 ashish 7029 
    try:
483 rajveer 7030 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7031 
    except TransactionServiceException, ex:
7032 
      result.ex = ex
483 rajveer 7033 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7034 
    result.write(oprot)
7035 
    oprot.writeMessageEnd()
7036 
    oprot.trans.flush()
7037 
 
4999 phani.kuma 7038 
  def process_getOrderList(self, seqid, iprot, oprot):
7039 
    args = getOrderList_args()
7040 
    args.read(iprot)
7041 
    iprot.readMessageEnd()
7042 
    result = getOrderList_result()
7043 
    result.success = self._handler.getOrderList(args.order_ids)
7044 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7045 
    result.write(oprot)
7046 
    oprot.writeMessageEnd()
7047 
    oprot.trans.flush()
7048 
 
5386 phani.kuma 7049 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7050 
    args = getOrderListForVendor_args()
7051 
    args.read(iprot)
7052 
    iprot.readMessageEnd()
7053 
    result = getOrderListForVendor_result()
7054 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7055 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7056 
    result.write(oprot)
7057 
    oprot.writeMessageEnd()
7058 
    oprot.trans.flush()
7059 
 
1528 ankur.sing 7060 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7061 
    args = getOrderForCustomer_args()
7062 
    args.read(iprot)
7063 
    iprot.readMessageEnd()
7064 
    result = getOrderForCustomer_result()
7065 
    try:
7066 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7067 
    except TransactionServiceException, ex:
7068 
      result.ex = ex
7069 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7070 
    result.write(oprot)
7071 
    oprot.writeMessageEnd()
7072 
    oprot.trans.flush()
7073 
 
3064 chandransh 7074 
  def process_getAlerts(self, seqid, iprot, oprot):
7075 
    args = getAlerts_args()
7076 
    args.read(iprot)
7077 
    iprot.readMessageEnd()
7078 
    result = getAlerts_result()
4444 rajveer 7079 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7080 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7081 
    result.write(oprot)
7082 
    oprot.writeMessageEnd()
7083 
    oprot.trans.flush()
7084 
 
4394 rajveer 7085 
  def process_addAlert(self, seqid, iprot, oprot):
7086 
    args = addAlert_args()
3064 chandransh 7087 
    args.read(iprot)
7088 
    iprot.readMessageEnd()
4394 rajveer 7089 
    result = addAlert_result()
4444 rajveer 7090 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7091 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7092 
    result.write(oprot)
7093 
    oprot.writeMessageEnd()
7094 
    oprot.trans.flush()
7095 
 
4444 rajveer 7096 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7097 
    args = markAlertsAsSeen_args()
7098 
    args.read(iprot)
7099 
    iprot.readMessageEnd()
7100 
    result = markAlertsAsSeen_result()
7101 
    self._handler.markAlertsAsSeen(args.warehouseId)
7102 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7103 
    result.write(oprot)
7104 
    oprot.writeMessageEnd()
7105 
    oprot.trans.flush()
7106 
 
3064 chandransh 7107 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7108 
    args = getValidOrderCount_args()
7109 
    args.read(iprot)
7110 
    iprot.readMessageEnd()
7111 
    result = getValidOrderCount_result()
7112 
    result.success = self._handler.getValidOrderCount()
7113 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7114 
    result.write(oprot)
7115 
    oprot.writeMessageEnd()
7116 
    oprot.trans.flush()
7117 
 
7118 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7119 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7120 
    args.read(iprot)
7121 
    iprot.readMessageEnd()
7122 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7123 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7124 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7125 
    result.write(oprot)
7126 
    oprot.writeMessageEnd()
7127 
    oprot.trans.flush()
7128 
 
7129 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7130 
    args = getValidOrdersAmountRange_args()
7131 
    args.read(iprot)
7132 
    iprot.readMessageEnd()
7133 
    result = getValidOrdersAmountRange_result()
7134 
    result.success = self._handler.getValidOrdersAmountRange()
7135 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7136 
    result.write(oprot)
7137 
    oprot.writeMessageEnd()
7138 
    oprot.trans.flush()
7139 
 
7140 
  def process_getValidOrders(self, seqid, iprot, oprot):
7141 
    args = getValidOrders_args()
7142 
    args.read(iprot)
7143 
    iprot.readMessageEnd()
7144 
    result = getValidOrders_result()
5874 rajveer 7145 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7146 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7147 
    result.write(oprot)
7148 
    oprot.writeMessageEnd()
7149 
    oprot.trans.flush()
7150 
 
1220 chandransh 7151 
  def process_batchOrders(self, seqid, iprot, oprot):
7152 
    args = batchOrders_args()
7153 
    args.read(iprot)
7154 
    iprot.readMessageEnd()
7155 
    result = batchOrders_result()
7156 
    try:
7157 
      result.success = self._handler.batchOrders(args.warehouseId)
7158 
    except TransactionServiceException, ex:
7159 
      result.ex = ex
7160 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7161 
    result.write(oprot)
7162 
    oprot.writeMessageEnd()
7163 
    oprot.trans.flush()
7164 
 
1208 chandransh 7165 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7166 
    args = markOrderAsOutOfStock_args()
7167 
    args.read(iprot)
7168 
    iprot.readMessageEnd()
7169 
    result = markOrderAsOutOfStock_result()
7170 
    try:
7171 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7172 
    except TransactionServiceException, ex:
7173 
      result.ex = ex
7174 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7175 
    result.write(oprot)
7176 
    oprot.writeMessageEnd()
7177 
    oprot.trans.flush()
7178 
 
3064 chandransh 7179 
  def process_verifyOrder(self, seqid, iprot, oprot):
7180 
    args = verifyOrder_args()
759 chandransh 7181 
    args.read(iprot)
7182 
    iprot.readMessageEnd()
3064 chandransh 7183 
    result = verifyOrder_result()
759 chandransh 7184 
    try:
3064 chandransh 7185 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7186 
    except TransactionServiceException, ex:
7187 
      result.ex = ex
3064 chandransh 7188 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7189 
    result.write(oprot)
7190 
    oprot.writeMessageEnd()
7191 
    oprot.trans.flush()
7192 
 
3064 chandransh 7193 
  def process_acceptOrder(self, seqid, iprot, oprot):
7194 
    args = acceptOrder_args()
1113 chandransh 7195 
    args.read(iprot)
7196 
    iprot.readMessageEnd()
3064 chandransh 7197 
    result = acceptOrder_result()
1113 chandransh 7198 
    try:
3064 chandransh 7199 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7200 
    except TransactionServiceException, ex:
7201 
      result.ex = ex
3064 chandransh 7202 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7203 
    result.write(oprot)
7204 
    oprot.writeMessageEnd()
7205 
    oprot.trans.flush()
7206 
 
3064 chandransh 7207 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7208 
    args = addBillingDetails_args()
1135 chandransh 7209 
    args.read(iprot)
7210 
    iprot.readMessageEnd()
3064 chandransh 7211 
    result = addBillingDetails_result()
1135 chandransh 7212 
    try:
5110 mandeep.dh 7213 
      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 7214 
    except TransactionServiceException, ex:
7215 
      result.ex = ex
3064 chandransh 7216 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7217 
    result.write(oprot)
7218 
    oprot.writeMessageEnd()
7219 
    oprot.trans.flush()
7220 
 
4579 rajveer 7221 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7222 
    args = addInvoiceNumber_args()
7223 
    args.read(iprot)
7224 
    iprot.readMessageEnd()
7225 
    result = addInvoiceNumber_result()
7226 
    try:
6756 amar.kumar 7227 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7228 
    except TransactionServiceException, ex:
7229 
      result.ex = ex
7230 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7231 
    result.write(oprot)
7232 
    oprot.writeMessageEnd()
7233 
    oprot.trans.flush()
7234 
 
4410 rajveer 7235 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7236 
    args = markOrdersAsShippedFromWarehouse_args()
7237 
    args.read(iprot)
7238 
    iprot.readMessageEnd()
7239 
    result = markOrdersAsShippedFromWarehouse_result()
7240 
    try:
4789 rajveer 7241 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7242 
    except TransactionServiceException, ex:
7243 
      result.ex = ex
7244 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7245 
    result.write(oprot)
7246 
    oprot.writeMessageEnd()
7247 
    oprot.trans.flush()
7248 
 
5676 rajveer 7249 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7250 
    args = markOrdersAsReturnedFromStore_args()
7251 
    args.read(iprot)
7252 
    iprot.readMessageEnd()
7253 
    result = markOrdersAsReturnedFromStore_result()
7254 
    try:
5713 rajveer 7255 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7256 
    except TransactionServiceException, ex:
7257 
      result.ex = ex
7258 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7259 
    result.write(oprot)
7260 
    oprot.writeMessageEnd()
7261 
    oprot.trans.flush()
7262 
 
3064 chandransh 7263 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7264 
    args = markOrdersAsPickedUp_args()
304 ashish 7265 
    args.read(iprot)
7266 
    iprot.readMessageEnd()
3064 chandransh 7267 
    result = markOrdersAsPickedUp_result()
7268 
    try:
4910 phani.kuma 7269 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7270 
    except TransactionServiceException, ex:
7271 
      result.ex = ex
7272 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
94 ashish 7276 
 
4910 phani.kuma 7277 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7278 
    args = getOrdersNotPickedUp_args()
7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
7281 
    result = getOrdersNotPickedUp_result()
7282 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7283 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7284 
    result.write(oprot)
7285 
    oprot.writeMessageEnd()
7286 
    oprot.trans.flush()
7287 
 
3064 chandransh 7288 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7289 
    args = markOrdersAsDelivered_args()
304 ashish 7290 
    args.read(iprot)
7291 
    iprot.readMessageEnd()
3064 chandransh 7292 
    result = markOrdersAsDelivered_result()
7293 
    try:
7294 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7295 
    except TransactionServiceException, ex:
7296 
      result.ex = ex
7297 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7298 
    result.write(oprot)
7299 
    oprot.writeMessageEnd()
7300 
    oprot.trans.flush()
7301 
 
4910 phani.kuma 7302 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7303 
    args = markAsRTOrders_args()
1596 ankur.sing 7304 
    args.read(iprot)
7305 
    iprot.readMessageEnd()
4910 phani.kuma 7306 
    result = markAsRTOrders_result()
3064 chandransh 7307 
    try:
4910 phani.kuma 7308 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7309 
    except TransactionServiceException, ex:
7310 
      result.ex = ex
4910 phani.kuma 7311 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7312 
    result.write(oprot)
7313 
    oprot.writeMessageEnd()
7314 
    oprot.trans.flush()
304 ashish 7315 
 
4910 phani.kuma 7316 
  def process_getRTOrders(self, seqid, iprot, oprot):
7317 
    args = getRTOrders_args()
7318 
    args.read(iprot)
7319 
    iprot.readMessageEnd()
7320 
    result = getRTOrders_result()
7321 
    result.success = self._handler.getRTOrders(args.providerId)
7322 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7323 
    result.write(oprot)
7324 
    oprot.writeMessageEnd()
7325 
    oprot.trans.flush()
7326 
 
3064 chandransh 7327 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7328 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7329 
    args.read(iprot)
7330 
    iprot.readMessageEnd()
3064 chandransh 7331 
    result = updateNonDeliveryReason_result()
7332 
    try:
4910 phani.kuma 7333 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7334 
    except TransactionServiceException, ex:
7335 
      result.ex = ex
7336 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7337 
    result.write(oprot)
7338 
    oprot.writeMessageEnd()
7339 
    oprot.trans.flush()
1596 ankur.sing 7340 
 
4910 phani.kuma 7341 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7342 
    args = getNonDeliveredOrdersbyCourier_args()
7343 
    args.read(iprot)
7344 
    iprot.readMessageEnd()
7345 
    result = getNonDeliveredOrdersbyCourier_result()
7346 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7347 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7348 
    result.write(oprot)
7349 
    oprot.writeMessageEnd()
7350 
    oprot.trans.flush()
7351 
 
7352 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7353 
    args = markOrdersAsLocalConnected_args()
7354 
    args.read(iprot)
7355 
    iprot.readMessageEnd()
7356 
    result = markOrdersAsLocalConnected_result()
7357 
    try:
7358 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7359 
    except TransactionServiceException, ex:
7360 
      result.ex = ex
7361 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7362 
    result.write(oprot)
7363 
    oprot.writeMessageEnd()
7364 
    oprot.trans.flush()
7365 
 
7366 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7367 
    args = getOrdersNotLocalConnected_args()
7368 
    args.read(iprot)
7369 
    iprot.readMessageEnd()
7370 
    result = getOrdersNotLocalConnected_result()
7371 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7372 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
7377 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7378 
    args = markOrdersAsDestinationCityReached_args()
7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
7381 
    result = markOrdersAsDestinationCityReached_result()
7382 
    try:
7383 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7384 
    except TransactionServiceException, ex:
7385 
      result.ex = ex
7386 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
7390 
 
7391 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7392 
    args = markOrdersAsFirstDeliveryAttempted_args()
7393 
    args.read(iprot)
7394 
    iprot.readMessageEnd()
7395 
    result = markOrdersAsFirstDeliveryAttempted_result()
7396 
    try:
7397 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7398 
    except TransactionServiceException, ex:
7399 
      result.ex = ex
7400 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7401 
    result.write(oprot)
7402 
    oprot.writeMessageEnd()
7403 
    oprot.trans.flush()
7404 
 
3064 chandransh 7405 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7406 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7407 
    args.read(iprot)
7408 
    iprot.readMessageEnd()
3064 chandransh 7409 
    result = getUndeliveredOrders_result()
7410 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7411 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7412 
    result.write(oprot)
7413 
    oprot.writeMessageEnd()
7414 
    oprot.trans.flush()
7415 
 
4783 phani.kuma 7416 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7417 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7418 
    args.read(iprot)
7419 
    iprot.readMessageEnd()
7420 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7421 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7422 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7423 
    result.write(oprot)
7424 
    oprot.writeMessageEnd()
7425 
    oprot.trans.flush()
7426 
 
2536 chandransh 7427 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7428 
    args = toggleDOAFlag_args()
7429 
    args.read(iprot)
7430 
    iprot.readMessageEnd()
7431 
    result = toggleDOAFlag_result()
7432 
    try:
7433 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7434 
    except TransactionServiceException, ex:
7435 
      result.ex = ex
7436 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7437 
    result.write(oprot)
7438 
    oprot.writeMessageEnd()
7439 
    oprot.trans.flush()
1886 ankur.sing 7440 
 
4712 rajveer 7441 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7442 
    args = markOrderAsDelivered_args()
7443 
    args.read(iprot)
7444 
    iprot.readMessageEnd()
7445 
    result = markOrderAsDelivered_result()
7446 
    try:
7447 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7448 
    except TransactionServiceException, ex:
7449 
      result.ex = ex
7450 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7451 
    result.write(oprot)
7452 
    oprot.writeMessageEnd()
7453 
    oprot.trans.flush()
7454 
 
5553 rajveer 7455 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7456 
    args = markOrderAsReceivedAtStore_args()
7457 
    args.read(iprot)
7458 
    iprot.readMessageEnd()
7459 
    result = markOrderAsReceivedAtStore_result()
7460 
    try:
7461 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7462 
    except TransactionServiceException, ex:
7463 
      result.ex = ex
7464 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7465 
    result.write(oprot)
7466 
    oprot.writeMessageEnd()
7467 
    oprot.trans.flush()
7468 
 
4454 rajveer 7469 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7470 
    args = markOrderDoaRequestReceived_args()
7471 
    args.read(iprot)
7472 
    iprot.readMessageEnd()
7473 
    result = markOrderDoaRequestReceived_result()
7474 
    try:
7475 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7476 
    except TransactionServiceException, ex:
7477 
      result.ex = ex
7478 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7479 
    result.write(oprot)
7480 
    oprot.writeMessageEnd()
7481 
    oprot.trans.flush()
7482 
 
7483 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7484 
    args = markOrderDoaRequestAuthorized_args()
7485 
    args.read(iprot)
7486 
    iprot.readMessageEnd()
7487 
    result = markOrderDoaRequestAuthorized_result()
7488 
    try:
7489 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7490 
    except TransactionServiceException, ex:
7491 
      result.ex = ex
7492 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7493 
    result.write(oprot)
7494 
    oprot.writeMessageEnd()
7495 
    oprot.trans.flush()
7496 
 
4488 rajveer 7497 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7498 
    args = markOrderReturnRequestReceived_args()
7499 
    args.read(iprot)
7500 
    iprot.readMessageEnd()
7501 
    result = markOrderReturnRequestReceived_result()
7502 
    try:
7503 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7504 
    except TransactionServiceException, ex:
7505 
      result.ex = ex
7506 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7507 
    result.write(oprot)
7508 
    oprot.writeMessageEnd()
7509 
    oprot.trans.flush()
7510 
 
7511 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7512 
    args = markOrderReturnRequestAuthorized_args()
7513 
    args.read(iprot)
7514 
    iprot.readMessageEnd()
7515 
    result = markOrderReturnRequestAuthorized_result()
7516 
    try:
7517 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7518 
    except TransactionServiceException, ex:
7519 
      result.ex = ex
7520 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7521 
    result.write(oprot)
7522 
    oprot.writeMessageEnd()
7523 
    oprot.trans.flush()
7524 
 
2536 chandransh 7525 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7526 
    args = requestPickupNumber_args()
7527 
    args.read(iprot)
7528 
    iprot.readMessageEnd()
7529 
    result = requestPickupNumber_result()
7530 
    try:
4579 rajveer 7531 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7532 
    except TransactionServiceException, ex:
7533 
      result.ex = ex
7534 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7535 
    result.write(oprot)
7536 
    oprot.writeMessageEnd()
7537 
    oprot.trans.flush()
7538 
 
7539 
  def process_authorizePickup(self, seqid, iprot, oprot):
7540 
    args = authorizePickup_args()
7541 
    args.read(iprot)
7542 
    iprot.readMessageEnd()
7543 
    result = authorizePickup_result()
7544 
    try:
4602 rajveer 7545 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7546 
    except TransactionServiceException, ex:
7547 
      result.ex = ex
7548 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7549 
    result.write(oprot)
7550 
    oprot.writeMessageEnd()
7551 
    oprot.trans.flush()
7552 
 
2764 chandransh 7553 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7554 
    args = markDoasAsPickedUp_args()
7555 
    args.read(iprot)
7556 
    iprot.readMessageEnd()
7557 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7558 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7559 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7560 
    result.write(oprot)
7561 
    oprot.writeMessageEnd()
7562 
    oprot.trans.flush()
7563 
 
4910 phani.kuma 7564 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7565 
    args = getDoasNotPickedUp_args()
7566 
    args.read(iprot)
7567 
    iprot.readMessageEnd()
7568 
    result = getDoasNotPickedUp_result()
7569 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7570 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7571 
    result.write(oprot)
7572 
    oprot.writeMessageEnd()
7573 
    oprot.trans.flush()
7574 
 
4741 phani.kuma 7575 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7576 
    args = markReturnOrdersAsPickedUp_args()
7577 
    args.read(iprot)
7578 
    iprot.readMessageEnd()
7579 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7580 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7581 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7582 
    result.write(oprot)
7583 
    oprot.writeMessageEnd()
7584 
    oprot.trans.flush()
7585 
 
4910 phani.kuma 7586 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7587 
    args = getReturnOrdersNotPickedUp_args()
7588 
    args.read(iprot)
7589 
    iprot.readMessageEnd()
7590 
    result = getReturnOrdersNotPickedUp_result()
7591 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7592 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7593 
    result.write(oprot)
7594 
    oprot.writeMessageEnd()
7595 
    oprot.trans.flush()
7596 
 
2616 chandransh 7597 
  def process_receiveReturn(self, seqid, iprot, oprot):
7598 
    args = receiveReturn_args()
2591 chandransh 7599 
    args.read(iprot)
7600 
    iprot.readMessageEnd()
2616 chandransh 7601 
    result = receiveReturn_result()
2591 chandransh 7602 
    try:
4479 rajveer 7603 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7604 
    except TransactionServiceException, ex:
7605 
      result.ex = ex
2616 chandransh 7606 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7607 
    result.write(oprot)
7608 
    oprot.writeMessageEnd()
7609 
    oprot.trans.flush()
2536 chandransh 7610 
 
2591 chandransh 7611 
  def process_validateDoa(self, seqid, iprot, oprot):
7612 
    args = validateDoa_args()
7613 
    args.read(iprot)
7614 
    iprot.readMessageEnd()
7615 
    result = validateDoa_result()
7616 
    try:
7617 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7618 
    except TransactionServiceException, ex:
7619 
      result.ex = ex
7620 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7621 
    result.write(oprot)
7622 
    oprot.writeMessageEnd()
7623 
    oprot.trans.flush()
7624 
 
4495 rajveer 7625 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7626 
    args = validateReturnProduct_args()
7627 
    args.read(iprot)
7628 
    iprot.readMessageEnd()
7629 
    result = validateReturnProduct_result()
7630 
    try:
7631 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7632 
    except TransactionServiceException, ex:
7633 
      result.ex = ex
7634 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7635 
    result.write(oprot)
7636 
    oprot.writeMessageEnd()
7637 
    oprot.trans.flush()
7638 
 
2616 chandransh 7639 
  def process_reshipOrder(self, seqid, iprot, oprot):
7640 
    args = reshipOrder_args()
7641 
    args.read(iprot)
7642 
    iprot.readMessageEnd()
7643 
    result = reshipOrder_result()
7644 
    try:
7645 
      result.success = self._handler.reshipOrder(args.orderId)
7646 
    except TransactionServiceException, ex:
7647 
      result.ex = ex
7648 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7649 
    result.write(oprot)
7650 
    oprot.writeMessageEnd()
7651 
    oprot.trans.flush()
2591 chandransh 7652 
 
2616 chandransh 7653 
  def process_refundOrder(self, seqid, iprot, oprot):
7654 
    args = refundOrder_args()
7655 
    args.read(iprot)
7656 
    iprot.readMessageEnd()
7657 
    result = refundOrder_result()
7658 
    try:
3226 chandransh 7659 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7660 
    except TransactionServiceException, ex:
7661 
      result.ex = ex
7662 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7663 
    result.write(oprot)
7664 
    oprot.writeMessageEnd()
7665 
    oprot.trans.flush()
7666 
 
2690 chandransh 7667 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7668 
    args = getReturnOrders_args()
7669 
    args.read(iprot)
7670 
    iprot.readMessageEnd()
7671 
    result = getReturnOrders_result()
7672 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7673 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7674 
    result.write(oprot)
7675 
    oprot.writeMessageEnd()
7676 
    oprot.trans.flush()
2616 chandransh 7677 
 
5481 phani.kuma 7678 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7679 
    args = getAllReturnOrders_args()
7680 
    args.read(iprot)
7681 
    iprot.readMessageEnd()
7682 
    result = getAllReturnOrders_result()
7683 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7684 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7685 
    result.write(oprot)
7686 
    oprot.writeMessageEnd()
7687 
    oprot.trans.flush()
7688 
 
2700 chandransh 7689 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7690 
    args = getReturnOrder_args()
7691 
    args.read(iprot)
7692 
    iprot.readMessageEnd()
7693 
    result = getReturnOrder_result()
7694 
    try:
7695 
      result.success = self._handler.getReturnOrder(args.id)
7696 
    except TransactionServiceException, ex:
7697 
      result.ex = ex
7698 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7699 
    result.write(oprot)
7700 
    oprot.writeMessageEnd()
7701 
    oprot.trans.flush()
7702 
 
2690 chandransh 7703 
  def process_processReturn(self, seqid, iprot, oprot):
7704 
    args = processReturn_args()
7705 
    args.read(iprot)
7706 
    iprot.readMessageEnd()
7707 
    result = processReturn_result()
7708 
    try:
7709 
      self._handler.processReturn(args.returnOrderId)
7710 
    except TransactionServiceException, ex:
7711 
      result.ex = ex
7712 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7713 
    result.write(oprot)
7714 
    oprot.writeMessageEnd()
7715 
    oprot.trans.flush()
7716 
 
3451 chandransh 7717 
  def process_updateWeight(self, seqid, iprot, oprot):
7718 
    args = updateWeight_args()
7719 
    args.read(iprot)
7720 
    iprot.readMessageEnd()
7721 
    result = updateWeight_result()
7722 
    try:
7723 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7724 
    except TransactionServiceException, ex:
7725 
      result.ex = ex
7726 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7727 
    result.write(oprot)
7728 
    oprot.writeMessageEnd()
7729 
    oprot.trans.flush()
2819 chandransh 7730 
 
3469 chandransh 7731 
  def process_changeItem(self, seqid, iprot, oprot):
7732 
    args = changeItem_args()
7733 
    args.read(iprot)
7734 
    iprot.readMessageEnd()
7735 
    result = changeItem_result()
7736 
    try:
7737 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7738 
    except TransactionServiceException, ex:
7739 
      result.ex = ex
7740 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7741 
    result.write(oprot)
7742 
    oprot.writeMessageEnd()
7743 
    oprot.trans.flush()
3451 chandransh 7744 
 
3469 chandransh 7745 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7746 
    args = shiftToWarehouse_args()
7747 
    args.read(iprot)
7748 
    iprot.readMessageEnd()
7749 
    result = shiftToWarehouse_result()
7750 
    try:
7751 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7752 
    except TransactionServiceException, ex:
7753 
      result.ex = ex
7754 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7755 
    result.write(oprot)
7756 
    oprot.writeMessageEnd()
7757 
    oprot.trans.flush()
7758 
 
3553 chandransh 7759 
  def process_addDelayReason(self, seqid, iprot, oprot):
7760 
    args = addDelayReason_args()
7761 
    args.read(iprot)
7762 
    iprot.readMessageEnd()
7763 
    result = addDelayReason_result()
7764 
    try:
4647 rajveer 7765 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7766 
    except TransactionServiceException, ex:
7767 
      result.ex = ex
7768 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7769 
    result.write(oprot)
7770 
    oprot.writeMessageEnd()
7771 
    oprot.trans.flush()
3469 chandransh 7772 
 
3956 chandransh 7773 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7774 
    args = reconcileCodCollection_args()
7775 
    args.read(iprot)
7776 
    iprot.readMessageEnd()
7777 
    result = reconcileCodCollection_result()
7778 
    try:
7779 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7780 
    except TransactionServiceException, ex:
7781 
      result.ex = ex
7782 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7783 
    result.write(oprot)
7784 
    oprot.writeMessageEnd()
7785 
    oprot.trans.flush()
3553 chandransh 7786 
 
4008 mandeep.dh 7787 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7788 
    args = getTransactionsRequiringExtraProcessing_args()
7789 
    args.read(iprot)
7790 
    iprot.readMessageEnd()
7791 
    result = getTransactionsRequiringExtraProcessing_result()
7792 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7793 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7794 
    result.write(oprot)
7795 
    oprot.writeMessageEnd()
7796 
    oprot.trans.flush()
3956 chandransh 7797 
 
4008 mandeep.dh 7798 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7799 
    args = markTransactionAsProcessed_args()
7800 
    args.read(iprot)
7801 
    iprot.readMessageEnd()
7802 
    result = markTransactionAsProcessed_result()
7803 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7804 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7805 
    result.write(oprot)
7806 
    oprot.writeMessageEnd()
7807 
    oprot.trans.flush()
7808 
 
4018 chandransh 7809 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7810 
    args = getItemWiseRiskyOrdersCount_args()
7811 
    args.read(iprot)
7812 
    iprot.readMessageEnd()
7813 
    result = getItemWiseRiskyOrdersCount_result()
7814 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7815 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7816 
    result.write(oprot)
7817 
    oprot.writeMessageEnd()
7818 
    oprot.trans.flush()
4008 mandeep.dh 7819 
 
4295 varun.gupt 7820 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7821 
    args = getOrdersForItemIds_args()
7822 
    args.read(iprot)
7823 
    iprot.readMessageEnd()
7824 
    result = getOrdersForItemIds_result()
7825 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7826 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7827 
    result.write(oprot)
7828 
    oprot.writeMessageEnd()
7829 
    oprot.trans.flush()
7830 
 
4247 rajveer 7831 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7832 
    args = markOrderCancellationRequestReceived_args()
7833 
    args.read(iprot)
7834 
    iprot.readMessageEnd()
7835 
    result = markOrderCancellationRequestReceived_result()
7836 
    try:
7837 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7838 
    except TransactionServiceException, ex:
7839 
      result.ex = ex
7840 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
4018 chandransh 7844 
 
4247 rajveer 7845 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7846 
    args = markOrderCancellationRequestConfirmed_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = markOrderCancellationRequestConfirmed_result()
7850 
    try:
7851 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7852 
    except TransactionServiceException, ex:
7853 
      result.ex = ex
7854 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
7859 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7860 
    args = markOrderCancellationRequestDenied_args()
7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
7863 
    result = markOrderCancellationRequestDenied_result()
7864 
    try:
7865 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7866 
    except TransactionServiceException, ex:
7867 
      result.ex = ex
7868 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
7872 
 
4258 rajveer 7873 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7874 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
4258 rajveer 7877 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7878 
    try:
4258 rajveer 7879 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7880 
    except TransactionServiceException, ex:
7881 
      result.ex = ex
4258 rajveer 7882 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7883 
    result.write(oprot)
7884 
    oprot.writeMessageEnd()
7885 
    oprot.trans.flush()
7886 
 
4259 anupam.sin 7887 
  def process_refundTransaction(self, seqid, iprot, oprot):
7888 
    args = refundTransaction_args()
7889 
    args.read(iprot)
7890 
    iprot.readMessageEnd()
7891 
    result = refundTransaction_result()
7892 
    try:
7893 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7894 
    except TransactionServiceException, ex:
7895 
      result.ex = ex
7896 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
4247 rajveer 7900 
 
4324 mandeep.dh 7901 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7902 
    args = updateShipmentAddress_args()
7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
7905 
    result = updateShipmentAddress_result()
7906 
    try:
7907 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7908 
    except TransactionServiceException, ex:
7909 
      result.ex = ex
7910 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7911 
    result.write(oprot)
7912 
    oprot.writeMessageEnd()
7913 
    oprot.trans.flush()
7914 
 
4285 rajveer 7915 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7916 
    args = acceptOrdersForItemId_args()
7917 
    args.read(iprot)
7918 
    iprot.readMessageEnd()
7919 
    result = acceptOrdersForItemId_result()
7920 
    try:
7921 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7922 
    except TransactionServiceException, ex:
7923 
      result.ex = ex
7924 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
4259 anupam.sin 7928 
 
4303 rajveer 7929 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7930 
    args = markOrdersAsPORaised_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = markOrdersAsPORaised_result()
7934 
    try:
4369 rajveer 7935 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7936 
    except TransactionServiceException, ex:
7937 
      result.ex = ex
7938 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7939 
    result.write(oprot)
7940 
    oprot.writeMessageEnd()
7941 
    oprot.trans.flush()
4285 rajveer 7942 
 
4303 rajveer 7943 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7944 
    args = markOrdersAsReversalInitiated_args()
7945 
    args.read(iprot)
7946 
    iprot.readMessageEnd()
7947 
    result = markOrdersAsReversalInitiated_result()
7948 
    try:
4369 rajveer 7949 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7950 
    except TransactionServiceException, ex:
7951 
      result.ex = ex
7952 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7953 
    result.write(oprot)
7954 
    oprot.writeMessageEnd()
7955 
    oprot.trans.flush()
7956 
 
7957 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7958 
    args = markOrdersAsNotAvailabke_args()
7959 
    args.read(iprot)
7960 
    iprot.readMessageEnd()
7961 
    result = markOrdersAsNotAvailabke_result()
7962 
    try:
4369 rajveer 7963 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7964 
    except TransactionServiceException, ex:
7965 
      result.ex = ex
7966 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7967 
    result.write(oprot)
7968 
    oprot.writeMessageEnd()
7969 
    oprot.trans.flush()
7970 
 
4369 rajveer 7971 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7972 
    args = markOrdersAsTimeout_args()
7973 
    args.read(iprot)
7974 
    iprot.readMessageEnd()
7975 
    result = markOrdersAsTimeout_result()
7976 
    try:
7977 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7978 
    except TransactionServiceException, ex:
7979 
      result.ex = ex
7980 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7981 
    result.write(oprot)
7982 
    oprot.writeMessageEnd()
7983 
    oprot.trans.flush()
4303 rajveer 7984 
 
4662 rajveer 7985 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7986 
    args = markOrderAsLostInTransit_args()
7987 
    args.read(iprot)
7988 
    iprot.readMessageEnd()
7989 
    result = markOrderAsLostInTransit_result()
7990 
    try:
7991 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7992 
    except TransactionServiceException, ex:
7993 
      result.ex = ex
7994 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7995 
    result.write(oprot)
7996 
    oprot.writeMessageEnd()
7997 
    oprot.trans.flush()
7998 
 
4386 anupam.sin 7999 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8000 
    args = getOrderForAwb_args()
8001 
    args.read(iprot)
8002 
    iprot.readMessageEnd()
8003 
    result = getOrderForAwb_result()
8004 
    try:
8005 
      result.success = self._handler.getOrderForAwb(args.awb)
8006 
    except TransactionServiceException, ex:
8007 
      result.ex = ex
8008 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8009 
    result.write(oprot)
8010 
    oprot.writeMessageEnd()
8011 
    oprot.trans.flush()
4369 rajveer 8012 
 
4506 phani.kuma 8013 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8014 
    args = getOrdersForProviderForStatus_args()
8015 
    args.read(iprot)
8016 
    iprot.readMessageEnd()
8017 
    result = getOrdersForProviderForStatus_result()
8018 
    try:
4910 phani.kuma 8019 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8020 
    except TransactionServiceException, ex:
8021 
      result.ex = ex
8022 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8023 
    result.write(oprot)
8024 
    oprot.writeMessageEnd()
8025 
    oprot.trans.flush()
4386 anupam.sin 8026 
 
4600 varun.gupt 8027 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8028 
    args = getBilledOrdersForVendor_args()
8029 
    args.read(iprot)
8030 
    iprot.readMessageEnd()
8031 
    result = getBilledOrdersForVendor_result()
8032 
    try:
8033 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8034 
    except TransactionServiceException, ex:
8035 
      result.ex = ex
8036 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8037 
    result.write(oprot)
8038 
    oprot.writeMessageEnd()
8039 
    oprot.trans.flush()
4506 phani.kuma 8040 
 
4607 rajveer 8041 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8042 
    args = getSlippedSippingDateOrders_args()
8043 
    args.read(iprot)
8044 
    iprot.readMessageEnd()
8045 
    result = getSlippedSippingDateOrders_result()
8046 
    try:
8047 
      result.success = self._handler.getSlippedSippingDateOrders()
8048 
    except TransactionServiceException, ex:
8049 
      result.ex = ex
8050 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8051 
    result.write(oprot)
8052 
    oprot.writeMessageEnd()
8053 
    oprot.trans.flush()
8054 
 
4709 rajveer 8055 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8056 
    args = getCancelledOrders_args()
8057 
    args.read(iprot)
8058 
    iprot.readMessageEnd()
8059 
    result = getCancelledOrders_result()
8060 
    try:
8061 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8062 
    except TransactionServiceException, ex:
8063 
      result.ex = ex
8064 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8065 
    result.write(oprot)
8066 
    oprot.writeMessageEnd()
8067 
    oprot.trans.flush()
8068 
 
4600 varun.gupt 8069 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8070 
    args = saveBluedartSettlements_args()
8071 
    args.read(iprot)
8072 
    iprot.readMessageEnd()
8073 
    result = saveBluedartSettlements_result()
8074 
    try:
8075 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8076 
    except TransactionServiceException, ex:
8077 
      result.ex = ex
8078 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8079 
    result.write(oprot)
8080 
    oprot.writeMessageEnd()
8081 
    oprot.trans.flush()
8082 
 
8083 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8084 
    args = savePaymentSettlements_args()
8085 
    args.read(iprot)
8086 
    iprot.readMessageEnd()
8087 
    result = savePaymentSettlements_result()
8088 
    try:
4905 varun.gupt 8089 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8090 
    except TransactionServiceException, ex:
8091 
      result.ex = ex
8092 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8093 
    result.write(oprot)
8094 
    oprot.writeMessageEnd()
8095 
    oprot.trans.flush()
8096 
 
8097 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8098 
    args = saveEBSSettlementSummary_args()
8099 
    args.read(iprot)
8100 
    iprot.readMessageEnd()
8101 
    result = saveEBSSettlementSummary_result()
8102 
    try:
8103 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8104 
    except TransactionServiceException, ex:
8105 
      result.ex = ex
8106 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8107 
    result.write(oprot)
8108 
    oprot.writeMessageEnd()
8109 
    oprot.trans.flush()
8110 
 
5386 phani.kuma 8111 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8112 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8113 
    args.read(iprot)
8114 
    iprot.readMessageEnd()
5386 phani.kuma 8115 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8116 
    try:
5386 phani.kuma 8117 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8118 
    except TransactionServiceException, ex:
8119 
      result.ex = ex
5386 phani.kuma 8120 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8121 
    result.write(oprot)
8122 
    oprot.writeMessageEnd()
8123 
    oprot.trans.flush()
8124 
 
5386 phani.kuma 8125 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8126 
    args = getSettlementForCod_args()
8127 
    args.read(iprot)
8128 
    iprot.readMessageEnd()
8129 
    result = getSettlementForCod_result()
8130 
    try:
8131 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8132 
    except TransactionServiceException, ex:
8133 
      result.ex = ex
8134 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8135 
    result.write(oprot)
8136 
    oprot.writeMessageEnd()
8137 
    oprot.trans.flush()
8138 
 
4600 varun.gupt 8139 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8140 
    args = getEBSSettlementSummaries_args()
8141 
    args.read(iprot)
8142 
    iprot.readMessageEnd()
8143 
    result = getEBSSettlementSummaries_result()
8144 
    try:
8145 
      result.success = self._handler.getEBSSettlementSummaries()
8146 
    except TransactionServiceException, ex:
8147 
      result.ex = ex
8148 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8149 
    result.write(oprot)
8150 
    oprot.writeMessageEnd()
8151 
    oprot.trans.flush()
8152 
 
8153 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8154 
    args = markEBSSettlementUploaded_args()
8155 
    args.read(iprot)
8156 
    iprot.readMessageEnd()
8157 
    result = markEBSSettlementUploaded_result()
8158 
    try:
8159 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8160 
    except TransactionServiceException, ex:
8161 
      result.ex = ex
8162 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8163 
    result.write(oprot)
8164 
    oprot.writeMessageEnd()
8165 
    oprot.trans.flush()
8166 
 
8167 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8168 
    args = getEBSSettlementDate_args()
8169 
    args.read(iprot)
8170 
    iprot.readMessageEnd()
8171 
    result = getEBSSettlementDate_result()
8172 
    try:
8173 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8174 
    except TransactionServiceException, ex:
8175 
      result.ex = ex
8176 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8177 
    result.write(oprot)
8178 
    oprot.writeMessageEnd()
8179 
    oprot.trans.flush()
8180 
 
4715 varun.gupt 8181 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8182 
    args = getSettlementsByDate_args()
8183 
    args.read(iprot)
8184 
    iprot.readMessageEnd()
8185 
    result = getSettlementsByDate_result()
8186 
    try:
8187 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8188 
    except TransactionServiceException, ex:
8189 
      result.ex = ex
8190 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8191 
    result.write(oprot)
8192 
    oprot.writeMessageEnd()
8193 
    oprot.trans.flush()
4600 varun.gupt 8194 
 
4715 varun.gupt 8195 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8196 
    args = getReshippedOrderIds_args()
8197 
    args.read(iprot)
8198 
    iprot.readMessageEnd()
8199 
    result = getReshippedOrderIds_result()
8200 
    try:
8201 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8202 
    except TransactionServiceException, ex:
8203 
      result.ex = ex
8204 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8205 
    result.write(oprot)
8206 
    oprot.writeMessageEnd()
8207 
    oprot.trans.flush()
8208 
 
5481 phani.kuma 8209 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8210 
    args = getBilledOrders_args()
4875 varun.gupt 8211 
    args.read(iprot)
8212 
    iprot.readMessageEnd()
5481 phani.kuma 8213 
    result = getBilledOrders_result()
4875 varun.gupt 8214 
    try:
5481 phani.kuma 8215 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8216 
    except TransactionServiceException, ex:
8217 
      result.ex = ex
5481 phani.kuma 8218 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8219 
    result.write(oprot)
8220 
    oprot.writeMessageEnd()
8221 
    oprot.trans.flush()
4757 mandeep.dh 8222 
 
5031 varun.gupt 8223 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8224 
    args = getStatusDistributionOfOrders_args()
8225 
    args.read(iprot)
8226 
    iprot.readMessageEnd()
8227 
    result = getStatusDistributionOfOrders_result()
8228 
    try:
8229 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8230 
    except TransactionServiceException, ex:
8231 
      result.ex = ex
8232 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8233 
    result.write(oprot)
8234 
    oprot.writeMessageEnd()
8235 
    oprot.trans.flush()
4875 varun.gupt 8236 
 
5067 varun.gupt 8237 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8238 
    args = getOrderIdsForStatus_args()
8239 
    args.read(iprot)
8240 
    iprot.readMessageEnd()
8241 
    result = getOrderIdsForStatus_result()
8242 
    try:
8243 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8244 
    except TransactionServiceException, ex:
8245 
      result.ex = ex
8246 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8247 
    result.write(oprot)
8248 
    oprot.writeMessageEnd()
8249 
    oprot.trans.flush()
5031 varun.gupt 8250 
 
5348 anupam.sin 8251 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8252 
    args = updateCODAgent_args()
8253 
    args.read(iprot)
8254 
    iprot.readMessageEnd()
8255 
    result = updateCODAgent_result()
8256 
    try:
8257 
      self._handler.updateCODAgent(args.agent, args.orderId)
8258 
    except TransactionServiceException, ex:
8259 
      result.ex = ex
8260 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8261 
    result.write(oprot)
8262 
    oprot.writeMessageEnd()
8263 
    oprot.trans.flush()
8264 
 
5099 varun.gupt 8265 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8266 
    args = updateOrderAsPaidToVendor_args()
8267 
    args.read(iprot)
8268 
    iprot.readMessageEnd()
8269 
    result = updateOrderAsPaidToVendor_result()
8270 
    try:
8271 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8272 
    except TransactionServiceException, ex:
8273 
      result.ex = ex
8274 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
5067 varun.gupt 8278 
 
5386 phani.kuma 8279 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8280 
    args = updateOrderOnlyAsPaidToVendor_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = updateOrderOnlyAsPaidToVendor_result()
8284 
    try:
8285 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8286 
    except TransactionServiceException, ex:
8287 
      result.ex = ex
8288 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8289 
    result.write(oprot)
8290 
    oprot.writeMessageEnd()
8291 
    oprot.trans.flush()
8292 
 
5208 varun.gupt 8293 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8294 
    args = getRefundedOrdersMarkedPaid_args()
8295 
    args.read(iprot)
8296 
    iprot.readMessageEnd()
8297 
    result = getRefundedOrdersMarkedPaid_result()
8298 
    try:
8299 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8300 
    except TransactionServiceException, ex:
8301 
      result.ex = ex
8302 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8303 
    result.write(oprot)
8304 
    oprot.writeMessageEnd()
8305 
    oprot.trans.flush()
5099 varun.gupt 8306 
 
5447 anupam.sin 8307 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8308 
    args = getAllVerificationAgents_args()
8309 
    args.read(iprot)
8310 
    iprot.readMessageEnd()
8311 
    result = getAllVerificationAgents_result()
8312 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8313 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8314 
    result.write(oprot)
8315 
    oprot.writeMessageEnd()
8316 
    oprot.trans.flush()
5208 varun.gupt 8317 
 
5527 anupam.sin 8318 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8319 
    args = getAllAttributesForOrderId_args()
8320 
    args.read(iprot)
8321 
    iprot.readMessageEnd()
8322 
    result = getAllAttributesForOrderId_result()
8323 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8324 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8325 
    result.write(oprot)
8326 
    oprot.writeMessageEnd()
8327 
    oprot.trans.flush()
5447 anupam.sin 8328 
 
5676 rajveer 8329 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8330 
    args = setOrderAttributes_args()
8331 
    args.read(iprot)
8332 
    iprot.readMessageEnd()
8333 
    result = setOrderAttributes_result()
8334 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8335 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8336 
    result.write(oprot)
8337 
    oprot.writeMessageEnd()
8338 
    oprot.trans.flush()
8339 
 
5527 anupam.sin 8340 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8341 
    args = setOrderAttributeForTransaction_args()
8342 
    args.read(iprot)
8343 
    iprot.readMessageEnd()
8344 
    result = setOrderAttributeForTransaction_result()
8345 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8346 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8347 
    result.write(oprot)
8348 
    oprot.writeMessageEnd()
8349 
    oprot.trans.flush()
8350 
 
5553 rajveer 8351 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8352 
    args = getReceivePendingOrders_args()
8353 
    args.read(iprot)
8354 
    iprot.readMessageEnd()
8355 
    result = getReceivePendingOrders_result()
8356 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8357 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8358 
    result.write(oprot)
8359 
    oprot.writeMessageEnd()
8360 
    oprot.trans.flush()
5527 anupam.sin 8361 
 
5553 rajveer 8362 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8363 
    args = getReceivedAtStoreOrders_args()
8364 
    args.read(iprot)
8365 
    iprot.readMessageEnd()
8366 
    result = getReceivedAtStoreOrders_result()
8367 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8368 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8369 
    result.write(oprot)
8370 
    oprot.writeMessageEnd()
8371 
    oprot.trans.flush()
8372 
 
5713 rajveer 8373 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8374 
    args = getOrdersCollectionAtStore_args()
8375 
    args.read(iprot)
8376 
    iprot.readMessageEnd()
8377 
    result = getOrdersCollectionAtStore_result()
8378 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8379 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8380 
    result.write(oprot)
8381 
    oprot.writeMessageEnd()
8382 
    oprot.trans.flush()
8383 
 
5833 rajveer 8384 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8385 
    args = getOrderAttributeValue_args()
8386 
    args.read(iprot)
8387 
    iprot.readMessageEnd()
8388 
    result = getOrderAttributeValue_result()
8389 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8390 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8391 
    result.write(oprot)
8392 
    oprot.writeMessageEnd()
8393 
    oprot.trans.flush()
8394 
 
6019 rajveer 8395 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8396 
    args = changeJacketNumber_args()
8397 
    args.read(iprot)
8398 
    iprot.readMessageEnd()
8399 
    result = changeJacketNumber_result()
8400 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8401 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8402 
    result.write(oprot)
8403 
    oprot.writeMessageEnd()
8404 
    oprot.trans.flush()
8405 
 
8406 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8407 
    args = markOrderAsRtoInTransit_args()
8408 
    args.read(iprot)
8409 
    iprot.readMessageEnd()
8410 
    result = markOrderAsRtoInTransit_result()
8411 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8412 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8413 
    result.write(oprot)
8414 
    oprot.writeMessageEnd()
8415 
    oprot.trans.flush()
8416 
 
5593 mandeep.dh 8417 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8418 
    args = acceptOrderForItem_args()
8419 
    args.read(iprot)
8420 
    iprot.readMessageEnd()
8421 
    result = acceptOrderForItem_result()
8422 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8423 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8424 
    result.write(oprot)
8425 
    oprot.writeMessageEnd()
8426 
    oprot.trans.flush()
5553 rajveer 8427 
 
6000 mandeep.dh 8428 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8429 
    args = createRechargeOrder_args()
8430 
    args.read(iprot)
8431 
    iprot.readMessageEnd()
8432 
    result = createRechargeOrder_result()
8433 
    try:
8434 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8435 
    except TransactionServiceException, ex:
8436 
      result.ex = ex
8437 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8438 
    result.write(oprot)
8439 
    oprot.writeMessageEnd()
8440 
    oprot.trans.flush()
5593 mandeep.dh 8441 
 
6031 rajveer 8442 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8443 
    args = getRechargeOrder_args()
8444 
    args.read(iprot)
8445 
    iprot.readMessageEnd()
8446 
    result = getRechargeOrder_result()
8447 
    try:
8448 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8449 
    except TransactionServiceException, ex:
8450 
      result.ex = ex
8451 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8452 
    result.write(oprot)
8453 
    oprot.writeMessageEnd()
8454 
    oprot.trans.flush()
8455 
 
8456 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8457 
    args = getRechargeOrders_args()
8458 
    args.read(iprot)
8459 
    iprot.readMessageEnd()
8460 
    result = getRechargeOrders_result()
8461 
    result.success = self._handler.getRechargeOrders(args.userId)
8462 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8463 
    result.write(oprot)
8464 
    oprot.writeMessageEnd()
8465 
    oprot.trans.flush()
8466 
 
6000 mandeep.dh 8467 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8468 
    args = updateRechargeOrderStatus_args()
8469 
    args.read(iprot)
8470 
    iprot.readMessageEnd()
8471 
    result = updateRechargeOrderStatus_result()
8472 
    try:
6031 rajveer 8473 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8474 
    except TransactionServiceException, ex:
8475 
      result.ex = ex
8476 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8477 
    result.write(oprot)
8478 
    oprot.writeMessageEnd()
8479 
    oprot.trans.flush()
8480 
 
8481 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8482 
    args = activateRechargeTxn_args()
8483 
    args.read(iprot)
8484 
    iprot.readMessageEnd()
8485 
    result = activateRechargeTxn_result()
8486 
    try:
6031 rajveer 8487 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8488 
    except TransactionServiceException, ex:
8489 
      result.ex = ex
8490 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8491 
    result.write(oprot)
8492 
    oprot.writeMessageEnd()
8493 
    oprot.trans.flush()
8494 
 
6031 rajveer 8495 
  def process_getUserWallet(self, seqid, iprot, oprot):
8496 
    args = getUserWallet_args()
6000 mandeep.dh 8497 
    args.read(iprot)
8498 
    iprot.readMessageEnd()
6031 rajveer 8499 
    result = getUserWallet_result()
8500 
    result.success = self._handler.getUserWallet(args.userId)
8501 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8502 
    result.write(oprot)
8503 
    oprot.writeMessageEnd()
8504 
    oprot.trans.flush()
8505 
 
6031 rajveer 8506 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8507 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8508 
    args.read(iprot)
8509 
    iprot.readMessageEnd()
6031 rajveer 8510 
    result = getUserWalletHistory_result()
8511 
    result.success = self._handler.getUserWalletHistory(args.userId)
8512 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8513 
    result.write(oprot)
8514 
    oprot.writeMessageEnd()
8515 
    oprot.trans.flush()
8516 
 
6050 anupam.sin 8517 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8518 
    args = getRechargeOrdersForTransaction_args()
8519 
    args.read(iprot)
8520 
    iprot.readMessageEnd()
8521 
    result = getRechargeOrdersForTransaction_result()
8522 
    try:
8523 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8524 
    except TransactionServiceException, ex:
8525 
      result.ex = ex
8526 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8527 
    result.write(oprot)
8528 
    oprot.writeMessageEnd()
8529 
    oprot.trans.flush()
8530 
 
6048 rajveer 8531 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8532 
    args = getServiceProviders_args()
8533 
    args.read(iprot)
8534 
    iprot.readMessageEnd()
8535 
    result = getServiceProviders_result()
6206 rajveer 8536 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8537 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8538 
    result.write(oprot)
8539 
    oprot.writeMessageEnd()
8540 
    oprot.trans.flush()
6000 mandeep.dh 8541 
 
6048 rajveer 8542 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8543 
    args = getServiceProviderForDevice_args()
8544 
    args.read(iprot)
8545 
    iprot.readMessageEnd()
8546 
    result = getServiceProviderForDevice_result()
6049 rajveer 8547 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8548 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8549 
    result.write(oprot)
8550 
    oprot.writeMessageEnd()
8551 
    oprot.trans.flush()
8552 
 
6269 rajveer 8553 
  def process_validateRecharge(self, seqid, iprot, oprot):
8554 
    args = validateRecharge_args()
8555 
    args.read(iprot)
8556 
    iprot.readMessageEnd()
8557 
    result = validateRecharge_result()
6591 anupam.sin 8558 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8559 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8560 
    result.write(oprot)
8561 
    oprot.writeMessageEnd()
8562 
    oprot.trans.flush()
8563 
 
6094 rajveer 8564 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8565 
    args = getRechargeOrdersForDevice_args()
8566 
    args.read(iprot)
8567 
    iprot.readMessageEnd()
8568 
    result = getRechargeOrdersForDevice_result()
8569 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8570 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8571 
    result.write(oprot)
8572 
    oprot.writeMessageEnd()
8573 
    oprot.trans.flush()
6048 rajveer 8574 
 
6094 rajveer 8575 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8576 
    args = addAmountToWallet_args()
8577 
    args.read(iprot)
8578 
    iprot.readMessageEnd()
8579 
    result = addAmountToWallet_result()
8580 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8581 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8582 
    result.write(oprot)
8583 
    oprot.writeMessageEnd()
8584 
    oprot.trans.flush()
8585 
 
6188 rajveer 8586 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8587 
    args = getRechargeStatistics_args()
8588 
    args.read(iprot)
8589 
    iprot.readMessageEnd()
8590 
    result = getRechargeStatistics_result()
8591 
    result.success = self._handler.getRechargeStatistics()
8592 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8593 
    result.write(oprot)
8594 
    oprot.writeMessageEnd()
8595 
    oprot.trans.flush()
8596 
 
6154 rajveer 8597 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8598 
    args = getRechargeOrdersForStatus_args()
8599 
    args.read(iprot)
8600 
    iprot.readMessageEnd()
8601 
    result = getRechargeOrdersForStatus_result()
8602 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8603 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8604 
    result.write(oprot)
8605 
    oprot.writeMessageEnd()
8606 
    oprot.trans.flush()
6094 rajveer 8607 
 
6159 rajveer 8608 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8609 
    args = getPlansForOperator_args()
8610 
    args.read(iprot)
8611 
    iprot.readMessageEnd()
8612 
    result = getPlansForOperator_result()
8613 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8614 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8615 
    result.write(oprot)
8616 
    oprot.writeMessageEnd()
8617 
    oprot.trans.flush()
6154 rajveer 8618 
 
6289 anupam.sin 8619 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8620 
    args = getRechargeDenominations_args()
8621 
    args.read(iprot)
8622 
    iprot.readMessageEnd()
8623 
    result = getRechargeDenominations_result()
8624 
    try:
6307 anupam.sin 8625 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8626 
    except TransactionServiceException, ex:
8627 
      result.ex = ex
8628 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8629 
    result.write(oprot)
8630 
    oprot.writeMessageEnd()
8631 
    oprot.trans.flush()
6159 rajveer 8632 
 
6371 rajveer 8633 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8634 
    args = updateAvailabilityStatus_args()
8635 
    args.read(iprot)
8636 
    iprot.readMessageEnd()
8637 
    result = updateAvailabilityStatus_result()
8638 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8639 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8640 
    result.write(oprot)
8641 
    oprot.writeMessageEnd()
8642 
    oprot.trans.flush()
6289 anupam.sin 8643 
 
6389 rajveer 8644 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8645 
    args = getAvailableEmiSchemes_args()
8646 
    args.read(iprot)
8647 
    iprot.readMessageEnd()
8648 
    result = getAvailableEmiSchemes_result()
8649 
    result.success = self._handler.getAvailableEmiSchemes()
8650 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8651 
    result.write(oprot)
8652 
    oprot.writeMessageEnd()
8653 
    oprot.trans.flush()
6371 rajveer 8654 
 
6389 rajveer 8655 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8656 
    args = getMiscCharges_args()
8657 
    args.read(iprot)
8658 
    iprot.readMessageEnd()
8659 
    result = getMiscCharges_result()
8660 
    result.success = self._handler.getMiscCharges(args.transactionId)
8661 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8662 
    result.write(oprot)
8663 
    oprot.writeMessageEnd()
8664 
    oprot.trans.flush()
8665 
 
6507 anupam.sin 8666 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8667 
    args = refundRechargeOrder_args()
8668 
    args.read(iprot)
8669 
    iprot.readMessageEnd()
8670 
    result = refundRechargeOrder_result()
8671 
    try:
8672 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8673 
    except TransactionServiceException, ex:
8674 
      result.ex = ex
8675 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8676 
    result.write(oprot)
8677 
    oprot.writeMessageEnd()
8678 
    oprot.trans.flush()
6389 rajveer 8679 
 
6821 amar.kumar 8680 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8681 
    args = getPhysicalOrders_args()
8682 
    args.read(iprot)
8683 
    iprot.readMessageEnd()
8684 
    result = getPhysicalOrders_result()
8685 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8686 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8687 
    result.write(oprot)
8688 
    oprot.writeMessageEnd()
8689 
    oprot.trans.flush()
6507 anupam.sin 8690 
 
6821 amar.kumar 8691 
 
94 ashish 8692 
# HELPER FUNCTIONS AND STRUCTURES
8693 
 
8694 
class createTransaction_args:
8695 
  """
8696 
  Attributes:
8697 
   - transaction
8698 
  """
8699 
 
8700 
  thrift_spec = (
8701 
    None, # 0
8702 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8703 
  )
8704 
 
8705 
  def __init__(self, transaction=None,):
8706 
    self.transaction = transaction
8707 
 
8708 
  def read(self, iprot):
8709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8711 
      return
8712 
    iprot.readStructBegin()
8713 
    while True:
8714 
      (fname, ftype, fid) = iprot.readFieldBegin()
8715 
      if ftype == TType.STOP:
8716 
        break
8717 
      if fid == 1:
8718 
        if ftype == TType.STRUCT:
8719 
          self.transaction = Transaction()
8720 
          self.transaction.read(iprot)
8721 
        else:
8722 
          iprot.skip(ftype)
8723 
      else:
8724 
        iprot.skip(ftype)
8725 
      iprot.readFieldEnd()
8726 
    iprot.readStructEnd()
8727 
 
8728 
  def write(self, oprot):
8729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8731 
      return
8732 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8733 
    if self.transaction is not None:
94 ashish 8734 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8735 
      self.transaction.write(oprot)
8736 
      oprot.writeFieldEnd()
8737 
    oprot.writeFieldStop()
8738 
    oprot.writeStructEnd()
8739 
 
3431 rajveer 8740 
  def validate(self):
8741 
    return
8742 
 
8743 
 
94 ashish 8744 
  def __repr__(self):
8745 
    L = ['%s=%r' % (key, value)
8746 
      for key, value in self.__dict__.iteritems()]
8747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8748 
 
8749 
  def __eq__(self, other):
8750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8751 
 
8752 
  def __ne__(self, other):
8753 
    return not (self == other)
8754 
 
8755 
class createTransaction_result:
8756 
  """
8757 
  Attributes:
132 ashish 8758 
   - success
94 ashish 8759 
   - ex
8760 
  """
8761 
 
8762 
  thrift_spec = (
132 ashish 8763 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8764 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8765 
  )
8766 
 
132 ashish 8767 
  def __init__(self, success=None, ex=None,):
8768 
    self.success = success
94 ashish 8769 
    self.ex = ex
8770 
 
8771 
  def read(self, iprot):
8772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8774 
      return
8775 
    iprot.readStructBegin()
8776 
    while True:
8777 
      (fname, ftype, fid) = iprot.readFieldBegin()
8778 
      if ftype == TType.STOP:
8779 
        break
132 ashish 8780 
      if fid == 0:
8781 
        if ftype == TType.I64:
8782 
          self.success = iprot.readI64();
8783 
        else:
8784 
          iprot.skip(ftype)
8785 
      elif fid == 1:
94 ashish 8786 
        if ftype == TType.STRUCT:
8787 
          self.ex = TransactionServiceException()
8788 
          self.ex.read(iprot)
8789 
        else:
8790 
          iprot.skip(ftype)
8791 
      else:
8792 
        iprot.skip(ftype)
8793 
      iprot.readFieldEnd()
8794 
    iprot.readStructEnd()
8795 
 
8796 
  def write(self, oprot):
8797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8799 
      return
8800 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8801 
    if self.success is not None:
132 ashish 8802 
      oprot.writeFieldBegin('success', TType.I64, 0)
8803 
      oprot.writeI64(self.success)
8804 
      oprot.writeFieldEnd()
3431 rajveer 8805 
    if self.ex is not None:
94 ashish 8806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8807 
      self.ex.write(oprot)
8808 
      oprot.writeFieldEnd()
8809 
    oprot.writeFieldStop()
8810 
    oprot.writeStructEnd()
8811 
 
3431 rajveer 8812 
  def validate(self):
8813 
    return
8814 
 
8815 
 
94 ashish 8816 
  def __repr__(self):
8817 
    L = ['%s=%r' % (key, value)
8818 
      for key, value in self.__dict__.iteritems()]
8819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8820 
 
8821 
  def __eq__(self, other):
8822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8823 
 
8824 
  def __ne__(self, other):
8825 
    return not (self == other)
8826 
 
8827 
class getTransaction_args:
8828 
  """
8829 
  Attributes:
8830 
   - id
8831 
  """
8832 
 
8833 
  thrift_spec = (
8834 
    None, # 0
8835 
    (1, TType.I64, 'id', None, None, ), # 1
8836 
  )
8837 
 
8838 
  def __init__(self, id=None,):
8839 
    self.id = id
8840 
 
8841 
  def read(self, iprot):
8842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8844 
      return
8845 
    iprot.readStructBegin()
8846 
    while True:
8847 
      (fname, ftype, fid) = iprot.readFieldBegin()
8848 
      if ftype == TType.STOP:
8849 
        break
8850 
      if fid == 1:
8851 
        if ftype == TType.I64:
8852 
          self.id = iprot.readI64();
8853 
        else:
8854 
          iprot.skip(ftype)
8855 
      else:
8856 
        iprot.skip(ftype)
8857 
      iprot.readFieldEnd()
8858 
    iprot.readStructEnd()
8859 
 
8860 
  def write(self, oprot):
8861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8863 
      return
8864 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8865 
    if self.id is not None:
94 ashish 8866 
      oprot.writeFieldBegin('id', TType.I64, 1)
8867 
      oprot.writeI64(self.id)
8868 
      oprot.writeFieldEnd()
8869 
    oprot.writeFieldStop()
8870 
    oprot.writeStructEnd()
8871 
 
3431 rajveer 8872 
  def validate(self):
8873 
    return
8874 
 
8875 
 
94 ashish 8876 
  def __repr__(self):
8877 
    L = ['%s=%r' % (key, value)
8878 
      for key, value in self.__dict__.iteritems()]
8879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8880 
 
8881 
  def __eq__(self, other):
8882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8883 
 
8884 
  def __ne__(self, other):
8885 
    return not (self == other)
8886 
 
8887 
class getTransaction_result:
8888 
  """
8889 
  Attributes:
8890 
   - success
8891 
   - ex
8892 
  """
8893 
 
8894 
  thrift_spec = (
8895 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8897 
  )
8898 
 
8899 
  def __init__(self, success=None, ex=None,):
8900 
    self.success = success
8901 
    self.ex = ex
8902 
 
8903 
  def read(self, iprot):
8904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8906 
      return
8907 
    iprot.readStructBegin()
8908 
    while True:
8909 
      (fname, ftype, fid) = iprot.readFieldBegin()
8910 
      if ftype == TType.STOP:
8911 
        break
8912 
      if fid == 0:
8913 
        if ftype == TType.STRUCT:
8914 
          self.success = Transaction()
8915 
          self.success.read(iprot)
8916 
        else:
8917 
          iprot.skip(ftype)
8918 
      elif fid == 1:
8919 
        if ftype == TType.STRUCT:
8920 
          self.ex = TransactionServiceException()
8921 
          self.ex.read(iprot)
8922 
        else:
8923 
          iprot.skip(ftype)
8924 
      else:
8925 
        iprot.skip(ftype)
8926 
      iprot.readFieldEnd()
8927 
    iprot.readStructEnd()
8928 
 
8929 
  def write(self, oprot):
8930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8932 
      return
8933 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8934 
    if self.success is not None:
94 ashish 8935 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8936 
      self.success.write(oprot)
8937 
      oprot.writeFieldEnd()
3431 rajveer 8938 
    if self.ex is not None:
94 ashish 8939 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8940 
      self.ex.write(oprot)
8941 
      oprot.writeFieldEnd()
8942 
    oprot.writeFieldStop()
8943 
    oprot.writeStructEnd()
8944 
 
3431 rajveer 8945 
  def validate(self):
8946 
    return
8947 
 
8948 
 
94 ashish 8949 
  def __repr__(self):
8950 
    L = ['%s=%r' % (key, value)
8951 
      for key, value in self.__dict__.iteritems()]
8952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8953 
 
8954 
  def __eq__(self, other):
8955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8956 
 
8957 
  def __ne__(self, other):
8958 
    return not (self == other)
8959 
 
8960 
class getTransactionsForCustomer_args:
8961 
  """
8962 
  Attributes:
8963 
   - customerId
8964 
   - from_date
8965 
   - to_date
8966 
   - status
8967 
  """
8968 
 
8969 
  thrift_spec = (
8970 
    None, # 0
8971 
    (1, TType.I64, 'customerId', None, None, ), # 1
8972 
    (2, TType.I64, 'from_date', None, None, ), # 2
8973 
    (3, TType.I64, 'to_date', None, None, ), # 3
8974 
    (4, TType.I32, 'status', None, None, ), # 4
8975 
  )
8976 
 
8977 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8978 
    self.customerId = customerId
8979 
    self.from_date = from_date
8980 
    self.to_date = to_date
8981 
    self.status = status
8982 
 
8983 
  def read(self, iprot):
8984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8986 
      return
8987 
    iprot.readStructBegin()
8988 
    while True:
8989 
      (fname, ftype, fid) = iprot.readFieldBegin()
8990 
      if ftype == TType.STOP:
8991 
        break
8992 
      if fid == 1:
8993 
        if ftype == TType.I64:
8994 
          self.customerId = iprot.readI64();
8995 
        else:
8996 
          iprot.skip(ftype)
8997 
      elif fid == 2:
8998 
        if ftype == TType.I64:
8999 
          self.from_date = iprot.readI64();
9000 
        else:
9001 
          iprot.skip(ftype)
9002 
      elif fid == 3:
9003 
        if ftype == TType.I64:
9004 
          self.to_date = iprot.readI64();
9005 
        else:
9006 
          iprot.skip(ftype)
9007 
      elif fid == 4:
9008 
        if ftype == TType.I32:
9009 
          self.status = iprot.readI32();
9010 
        else:
9011 
          iprot.skip(ftype)
9012 
      else:
9013 
        iprot.skip(ftype)
9014 
      iprot.readFieldEnd()
9015 
    iprot.readStructEnd()
9016 
 
9017 
  def write(self, oprot):
9018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9020 
      return
9021 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9022 
    if self.customerId is not None:
94 ashish 9023 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9024 
      oprot.writeI64(self.customerId)
9025 
      oprot.writeFieldEnd()
3431 rajveer 9026 
    if self.from_date is not None:
94 ashish 9027 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9028 
      oprot.writeI64(self.from_date)
9029 
      oprot.writeFieldEnd()
3431 rajveer 9030 
    if self.to_date is not None:
94 ashish 9031 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9032 
      oprot.writeI64(self.to_date)
9033 
      oprot.writeFieldEnd()
3431 rajveer 9034 
    if self.status is not None:
94 ashish 9035 
      oprot.writeFieldBegin('status', TType.I32, 4)
9036 
      oprot.writeI32(self.status)
9037 
      oprot.writeFieldEnd()
9038 
    oprot.writeFieldStop()
9039 
    oprot.writeStructEnd()
9040 
 
3431 rajveer 9041 
  def validate(self):
9042 
    return
9043 
 
9044 
 
94 ashish 9045 
  def __repr__(self):
9046 
    L = ['%s=%r' % (key, value)
9047 
      for key, value in self.__dict__.iteritems()]
9048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9049 
 
9050 
  def __eq__(self, other):
9051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9052 
 
9053 
  def __ne__(self, other):
9054 
    return not (self == other)
9055 
 
9056 
class getTransactionsForCustomer_result:
9057 
  """
9058 
  Attributes:
9059 
   - success
9060 
   - ex
9061 
  """
9062 
 
9063 
  thrift_spec = (
9064 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9066 
  )
9067 
 
9068 
  def __init__(self, success=None, ex=None,):
9069 
    self.success = success
9070 
    self.ex = ex
9071 
 
9072 
  def read(self, iprot):
9073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9075 
      return
9076 
    iprot.readStructBegin()
9077 
    while True:
9078 
      (fname, ftype, fid) = iprot.readFieldBegin()
9079 
      if ftype == TType.STOP:
9080 
        break
9081 
      if fid == 0:
9082 
        if ftype == TType.LIST:
9083 
          self.success = []
6188 rajveer 9084 
          (_etype109, _size106) = iprot.readListBegin()
9085 
          for _i110 in xrange(_size106):
9086 
            _elem111 = Transaction()
9087 
            _elem111.read(iprot)
9088 
            self.success.append(_elem111)
94 ashish 9089 
          iprot.readListEnd()
9090 
        else:
9091 
          iprot.skip(ftype)
9092 
      elif fid == 1:
9093 
        if ftype == TType.STRUCT:
9094 
          self.ex = TransactionServiceException()
9095 
          self.ex.read(iprot)
9096 
        else:
9097 
          iprot.skip(ftype)
9098 
      else:
9099 
        iprot.skip(ftype)
9100 
      iprot.readFieldEnd()
9101 
    iprot.readStructEnd()
9102 
 
9103 
  def write(self, oprot):
9104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9106 
      return
9107 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9108 
    if self.success is not None:
94 ashish 9109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9110 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9111 
      for iter112 in self.success:
9112 
        iter112.write(oprot)
94 ashish 9113 
      oprot.writeListEnd()
9114 
      oprot.writeFieldEnd()
3431 rajveer 9115 
    if self.ex is not None:
94 ashish 9116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9117 
      self.ex.write(oprot)
9118 
      oprot.writeFieldEnd()
9119 
    oprot.writeFieldStop()
9120 
    oprot.writeStructEnd()
9121 
 
3431 rajveer 9122 
  def validate(self):
9123 
    return
9124 
 
9125 
 
94 ashish 9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
132 ashish 9137 
class getTransactionsForShoppingCartId_args:
9138 
  """
9139 
  Attributes:
9140 
   - shoppingCartId
9141 
  """
9142 
 
9143 
  thrift_spec = (
9144 
    None, # 0
9145 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9146 
  )
9147 
 
9148 
  def __init__(self, shoppingCartId=None,):
9149 
    self.shoppingCartId = shoppingCartId
9150 
 
9151 
  def read(self, iprot):
9152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9154 
      return
9155 
    iprot.readStructBegin()
9156 
    while True:
9157 
      (fname, ftype, fid) = iprot.readFieldBegin()
9158 
      if ftype == TType.STOP:
9159 
        break
9160 
      if fid == 1:
9161 
        if ftype == TType.I64:
9162 
          self.shoppingCartId = iprot.readI64();
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9175 
    if self.shoppingCartId is not None:
132 ashish 9176 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9177 
      oprot.writeI64(self.shoppingCartId)
9178 
      oprot.writeFieldEnd()
9179 
    oprot.writeFieldStop()
9180 
    oprot.writeStructEnd()
9181 
 
3431 rajveer 9182 
  def validate(self):
9183 
    return
9184 
 
9185 
 
132 ashish 9186 
  def __repr__(self):
9187 
    L = ['%s=%r' % (key, value)
9188 
      for key, value in self.__dict__.iteritems()]
9189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9190 
 
9191 
  def __eq__(self, other):
9192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9193 
 
9194 
  def __ne__(self, other):
9195 
    return not (self == other)
9196 
 
9197 
class getTransactionsForShoppingCartId_result:
9198 
  """
9199 
  Attributes:
9200 
   - success
9201 
   - ex
9202 
  """
9203 
 
9204 
  thrift_spec = (
9205 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9207 
  )
9208 
 
9209 
  def __init__(self, success=None, ex=None,):
9210 
    self.success = success
9211 
    self.ex = ex
9212 
 
9213 
  def read(self, iprot):
9214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9216 
      return
9217 
    iprot.readStructBegin()
9218 
    while True:
9219 
      (fname, ftype, fid) = iprot.readFieldBegin()
9220 
      if ftype == TType.STOP:
9221 
        break
9222 
      if fid == 0:
9223 
        if ftype == TType.LIST:
9224 
          self.success = []
6188 rajveer 9225 
          (_etype116, _size113) = iprot.readListBegin()
9226 
          for _i117 in xrange(_size113):
9227 
            _elem118 = Transaction()
9228 
            _elem118.read(iprot)
9229 
            self.success.append(_elem118)
132 ashish 9230 
          iprot.readListEnd()
9231 
        else:
9232 
          iprot.skip(ftype)
9233 
      elif fid == 1:
9234 
        if ftype == TType.STRUCT:
9235 
          self.ex = TransactionServiceException()
9236 
          self.ex.read(iprot)
9237 
        else:
9238 
          iprot.skip(ftype)
9239 
      else:
9240 
        iprot.skip(ftype)
9241 
      iprot.readFieldEnd()
9242 
    iprot.readStructEnd()
9243 
 
9244 
  def write(self, oprot):
9245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9247 
      return
9248 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9249 
    if self.success is not None:
132 ashish 9250 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9251 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9252 
      for iter119 in self.success:
9253 
        iter119.write(oprot)
132 ashish 9254 
      oprot.writeListEnd()
9255 
      oprot.writeFieldEnd()
3431 rajveer 9256 
    if self.ex is not None:
132 ashish 9257 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9258 
      self.ex.write(oprot)
9259 
      oprot.writeFieldEnd()
9260 
    oprot.writeFieldStop()
9261 
    oprot.writeStructEnd()
9262 
 
3431 rajveer 9263 
  def validate(self):
9264 
    return
9265 
 
9266 
 
132 ashish 9267 
  def __repr__(self):
9268 
    L = ['%s=%r' % (key, value)
9269 
      for key, value in self.__dict__.iteritems()]
9270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9271 
 
9272 
  def __eq__(self, other):
9273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9274 
 
9275 
  def __ne__(self, other):
9276 
    return not (self == other)
9277 
 
94 ashish 9278 
class getTransactionStatus_args:
9279 
  """
9280 
  Attributes:
9281 
   - transactionId
9282 
  """
9283 
 
9284 
  thrift_spec = (
9285 
    None, # 0
9286 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9287 
  )
9288 
 
9289 
  def __init__(self, transactionId=None,):
9290 
    self.transactionId = transactionId
9291 
 
9292 
  def read(self, iprot):
9293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9295 
      return
9296 
    iprot.readStructBegin()
9297 
    while True:
9298 
      (fname, ftype, fid) = iprot.readFieldBegin()
9299 
      if ftype == TType.STOP:
9300 
        break
9301 
      if fid == 1:
9302 
        if ftype == TType.I64:
9303 
          self.transactionId = iprot.readI64();
9304 
        else:
9305 
          iprot.skip(ftype)
9306 
      else:
9307 
        iprot.skip(ftype)
9308 
      iprot.readFieldEnd()
9309 
    iprot.readStructEnd()
9310 
 
9311 
  def write(self, oprot):
9312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9314 
      return
9315 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9316 
    if self.transactionId is not None:
94 ashish 9317 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9318 
      oprot.writeI64(self.transactionId)
9319 
      oprot.writeFieldEnd()
9320 
    oprot.writeFieldStop()
9321 
    oprot.writeStructEnd()
9322 
 
3431 rajveer 9323 
  def validate(self):
9324 
    return
9325 
 
9326 
 
94 ashish 9327 
  def __repr__(self):
9328 
    L = ['%s=%r' % (key, value)
9329 
      for key, value in self.__dict__.iteritems()]
9330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9331 
 
9332 
  def __eq__(self, other):
9333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9334 
 
9335 
  def __ne__(self, other):
9336 
    return not (self == other)
9337 
 
9338 
class getTransactionStatus_result:
9339 
  """
9340 
  Attributes:
9341 
   - success
9342 
   - ex
9343 
  """
9344 
 
9345 
  thrift_spec = (
9346 
    (0, TType.I32, 'success', None, None, ), # 0
9347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9348 
  )
9349 
 
9350 
  def __init__(self, success=None, ex=None,):
9351 
    self.success = success
9352 
    self.ex = ex
9353 
 
9354 
  def read(self, iprot):
9355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9357 
      return
9358 
    iprot.readStructBegin()
9359 
    while True:
9360 
      (fname, ftype, fid) = iprot.readFieldBegin()
9361 
      if ftype == TType.STOP:
9362 
        break
9363 
      if fid == 0:
9364 
        if ftype == TType.I32:
9365 
          self.success = iprot.readI32();
9366 
        else:
9367 
          iprot.skip(ftype)
9368 
      elif fid == 1:
9369 
        if ftype == TType.STRUCT:
9370 
          self.ex = TransactionServiceException()
9371 
          self.ex.read(iprot)
9372 
        else:
9373 
          iprot.skip(ftype)
9374 
      else:
9375 
        iprot.skip(ftype)
9376 
      iprot.readFieldEnd()
9377 
    iprot.readStructEnd()
9378 
 
9379 
  def write(self, oprot):
9380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9382 
      return
9383 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9384 
    if self.success is not None:
94 ashish 9385 
      oprot.writeFieldBegin('success', TType.I32, 0)
9386 
      oprot.writeI32(self.success)
9387 
      oprot.writeFieldEnd()
3431 rajveer 9388 
    if self.ex is not None:
94 ashish 9389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9390 
      self.ex.write(oprot)
9391 
      oprot.writeFieldEnd()
9392 
    oprot.writeFieldStop()
9393 
    oprot.writeStructEnd()
9394 
 
3431 rajveer 9395 
  def validate(self):
9396 
    return
9397 
 
9398 
 
94 ashish 9399 
  def __repr__(self):
9400 
    L = ['%s=%r' % (key, value)
9401 
      for key, value in self.__dict__.iteritems()]
9402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9403 
 
9404 
  def __eq__(self, other):
9405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9406 
 
9407 
  def __ne__(self, other):
9408 
    return not (self == other)
9409 
 
9410 
class changeTransactionStatus_args:
9411 
  """
9412 
  Attributes:
9413 
   - transactionId
9414 
   - status
9415 
   - description
5527 anupam.sin 9416 
   - pickUp
9417 
   - orderType
94 ashish 9418 
  """
9419 
 
9420 
  thrift_spec = (
9421 
    None, # 0
9422 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9423 
    (2, TType.I32, 'status', None, None, ), # 2
9424 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9425 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9426 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9427 
  )
9428 
 
5527 anupam.sin 9429 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9430 
    self.transactionId = transactionId
9431 
    self.status = status
9432 
    self.description = description
5527 anupam.sin 9433 
    self.pickUp = pickUp
9434 
    self.orderType = orderType
94 ashish 9435 
 
9436 
  def read(self, iprot):
9437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9439 
      return
9440 
    iprot.readStructBegin()
9441 
    while True:
9442 
      (fname, ftype, fid) = iprot.readFieldBegin()
9443 
      if ftype == TType.STOP:
9444 
        break
9445 
      if fid == 1:
9446 
        if ftype == TType.I64:
9447 
          self.transactionId = iprot.readI64();
9448 
        else:
9449 
          iprot.skip(ftype)
9450 
      elif fid == 2:
9451 
        if ftype == TType.I32:
9452 
          self.status = iprot.readI32();
9453 
        else:
9454 
          iprot.skip(ftype)
9455 
      elif fid == 3:
9456 
        if ftype == TType.STRING:
9457 
          self.description = iprot.readString();
9458 
        else:
9459 
          iprot.skip(ftype)
5387 rajveer 9460 
      elif fid == 4:
5527 anupam.sin 9461 
        if ftype == TType.I64:
9462 
          self.pickUp = iprot.readI64();
5387 rajveer 9463 
        else:
9464 
          iprot.skip(ftype)
5527 anupam.sin 9465 
      elif fid == 5:
9466 
        if ftype == TType.I32:
9467 
          self.orderType = iprot.readI32();
9468 
        else:
9469 
          iprot.skip(ftype)
94 ashish 9470 
      else:
9471 
        iprot.skip(ftype)
9472 
      iprot.readFieldEnd()
9473 
    iprot.readStructEnd()
9474 
 
9475 
  def write(self, oprot):
9476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9478 
      return
9479 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9480 
    if self.transactionId is not None:
94 ashish 9481 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9482 
      oprot.writeI64(self.transactionId)
9483 
      oprot.writeFieldEnd()
3431 rajveer 9484 
    if self.status is not None:
94 ashish 9485 
      oprot.writeFieldBegin('status', TType.I32, 2)
9486 
      oprot.writeI32(self.status)
9487 
      oprot.writeFieldEnd()
3431 rajveer 9488 
    if self.description is not None:
94 ashish 9489 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9490 
      oprot.writeString(self.description)
9491 
      oprot.writeFieldEnd()
5527 anupam.sin 9492 
    if self.pickUp is not None:
9493 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9494 
      oprot.writeI64(self.pickUp)
5387 rajveer 9495 
      oprot.writeFieldEnd()
5527 anupam.sin 9496 
    if self.orderType is not None:
9497 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9498 
      oprot.writeI32(self.orderType)
9499 
      oprot.writeFieldEnd()
94 ashish 9500 
    oprot.writeFieldStop()
9501 
    oprot.writeStructEnd()
9502 
 
3431 rajveer 9503 
  def validate(self):
9504 
    return
9505 
 
9506 
 
94 ashish 9507 
  def __repr__(self):
9508 
    L = ['%s=%r' % (key, value)
9509 
      for key, value in self.__dict__.iteritems()]
9510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9511 
 
9512 
  def __eq__(self, other):
9513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9514 
 
9515 
  def __ne__(self, other):
9516 
    return not (self == other)
9517 
 
9518 
class changeTransactionStatus_result:
9519 
  """
9520 
  Attributes:
9521 
   - success
9522 
   - ex
9523 
  """
9524 
 
9525 
  thrift_spec = (
9526 
    (0, TType.BOOL, 'success', None, None, ), # 0
9527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9528 
  )
9529 
 
9530 
  def __init__(self, success=None, ex=None,):
9531 
    self.success = success
9532 
    self.ex = ex
9533 
 
9534 
  def read(self, iprot):
9535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9537 
      return
9538 
    iprot.readStructBegin()
9539 
    while True:
9540 
      (fname, ftype, fid) = iprot.readFieldBegin()
9541 
      if ftype == TType.STOP:
9542 
        break
9543 
      if fid == 0:
9544 
        if ftype == TType.BOOL:
9545 
          self.success = iprot.readBool();
9546 
        else:
9547 
          iprot.skip(ftype)
9548 
      elif fid == 1:
9549 
        if ftype == TType.STRUCT:
9550 
          self.ex = TransactionServiceException()
9551 
          self.ex.read(iprot)
9552 
        else:
9553 
          iprot.skip(ftype)
9554 
      else:
9555 
        iprot.skip(ftype)
9556 
      iprot.readFieldEnd()
9557 
    iprot.readStructEnd()
9558 
 
9559 
  def write(self, oprot):
9560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9562 
      return
9563 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9564 
    if self.success is not None:
94 ashish 9565 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9566 
      oprot.writeBool(self.success)
9567 
      oprot.writeFieldEnd()
3431 rajveer 9568 
    if self.ex is not None:
94 ashish 9569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9570 
      self.ex.write(oprot)
9571 
      oprot.writeFieldEnd()
9572 
    oprot.writeFieldStop()
9573 
    oprot.writeStructEnd()
9574 
 
3431 rajveer 9575 
  def validate(self):
9576 
    return
9577 
 
9578 
 
94 ashish 9579 
  def __repr__(self):
9580 
    L = ['%s=%r' % (key, value)
9581 
      for key, value in self.__dict__.iteritems()]
9582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9583 
 
9584 
  def __eq__(self, other):
9585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9586 
 
9587 
  def __ne__(self, other):
9588 
    return not (self == other)
9589 
 
1398 varun.gupt 9590 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9591 
  """
9592 
  Attributes:
9593 
   - transactionId
9594 
  """
9595 
 
9596 
  thrift_spec = (
9597 
    None, # 0
9598 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9599 
  )
9600 
 
9601 
  def __init__(self, transactionId=None,):
9602 
    self.transactionId = transactionId
9603 
 
9604 
  def read(self, iprot):
9605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9607 
      return
9608 
    iprot.readStructBegin()
9609 
    while True:
9610 
      (fname, ftype, fid) = iprot.readFieldBegin()
9611 
      if ftype == TType.STOP:
9612 
        break
9613 
      if fid == 1:
9614 
        if ftype == TType.I64:
9615 
          self.transactionId = iprot.readI64();
9616 
        else:
9617 
          iprot.skip(ftype)
9618 
      else:
9619 
        iprot.skip(ftype)
9620 
      iprot.readFieldEnd()
9621 
    iprot.readStructEnd()
9622 
 
9623 
  def write(self, oprot):
9624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9626 
      return
1398 varun.gupt 9627 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9628 
    if self.transactionId is not None:
1382 varun.gupt 9629 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9630 
      oprot.writeI64(self.transactionId)
9631 
      oprot.writeFieldEnd()
9632 
    oprot.writeFieldStop()
9633 
    oprot.writeStructEnd()
9634 
 
3431 rajveer 9635 
  def validate(self):
9636 
    return
9637 
 
9638 
 
1382 varun.gupt 9639 
  def __repr__(self):
9640 
    L = ['%s=%r' % (key, value)
9641 
      for key, value in self.__dict__.iteritems()]
9642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9643 
 
9644 
  def __eq__(self, other):
9645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9646 
 
9647 
  def __ne__(self, other):
9648 
    return not (self == other)
9649 
 
1398 varun.gupt 9650 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9651 
  """
9652 
  Attributes:
9653 
   - success
9654 
   - ex
9655 
  """
9656 
 
9657 
  thrift_spec = (
9658 
    (0, TType.BOOL, 'success', None, None, ), # 0
9659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9660 
  )
9661 
 
9662 
  def __init__(self, success=None, ex=None,):
9663 
    self.success = success
9664 
    self.ex = ex
9665 
 
9666 
  def read(self, iprot):
9667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9669 
      return
9670 
    iprot.readStructBegin()
9671 
    while True:
9672 
      (fname, ftype, fid) = iprot.readFieldBegin()
9673 
      if ftype == TType.STOP:
9674 
        break
9675 
      if fid == 0:
9676 
        if ftype == TType.BOOL:
9677 
          self.success = iprot.readBool();
9678 
        else:
9679 
          iprot.skip(ftype)
9680 
      elif fid == 1:
9681 
        if ftype == TType.STRUCT:
9682 
          self.ex = TransactionServiceException()
9683 
          self.ex.read(iprot)
9684 
        else:
9685 
          iprot.skip(ftype)
9686 
      else:
9687 
        iprot.skip(ftype)
9688 
      iprot.readFieldEnd()
9689 
    iprot.readStructEnd()
9690 
 
9691 
  def write(self, oprot):
9692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9694 
      return
1398 varun.gupt 9695 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9696 
    if self.success is not None:
1382 varun.gupt 9697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9698 
      oprot.writeBool(self.success)
9699 
      oprot.writeFieldEnd()
3431 rajveer 9700 
    if self.ex is not None:
1382 varun.gupt 9701 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9702 
      self.ex.write(oprot)
9703 
      oprot.writeFieldEnd()
9704 
    oprot.writeFieldStop()
9705 
    oprot.writeStructEnd()
9706 
 
3431 rajveer 9707 
  def validate(self):
9708 
    return
9709 
 
9710 
 
1382 varun.gupt 9711 
  def __repr__(self):
9712 
    L = ['%s=%r' % (key, value)
9713 
      for key, value in self.__dict__.iteritems()]
9714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9715 
 
9716 
  def __eq__(self, other):
9717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9718 
 
9719 
  def __ne__(self, other):
9720 
    return not (self == other)
9721 
 
483 rajveer 9722 
class getAllOrders_args:
94 ashish 9723 
  """
9724 
  Attributes:
4801 anupam.sin 9725 
   - statuses
483 rajveer 9726 
   - from_date
9727 
   - to_date
9728 
   - warehouse_id
94 ashish 9729 
  """
9730 
 
9731 
  thrift_spec = (
9732 
    None, # 0
4801 anupam.sin 9733 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9734 
    (2, TType.I64, 'from_date', None, None, ), # 2
9735 
    (3, TType.I64, 'to_date', None, None, ), # 3
9736 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9737 
  )
9738 
 
4801 anupam.sin 9739 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9740 
    self.statuses = statuses
483 rajveer 9741 
    self.from_date = from_date
9742 
    self.to_date = to_date
9743 
    self.warehouse_id = warehouse_id
94 ashish 9744 
 
9745 
  def read(self, iprot):
9746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9748 
      return
9749 
    iprot.readStructBegin()
9750 
    while True:
9751 
      (fname, ftype, fid) = iprot.readFieldBegin()
9752 
      if ftype == TType.STOP:
9753 
        break
9754 
      if fid == 1:
4801 anupam.sin 9755 
        if ftype == TType.LIST:
9756 
          self.statuses = []
6188 rajveer 9757 
          (_etype123, _size120) = iprot.readListBegin()
9758 
          for _i124 in xrange(_size120):
9759 
            _elem125 = iprot.readI32();
9760 
            self.statuses.append(_elem125)
4801 anupam.sin 9761 
          iprot.readListEnd()
94 ashish 9762 
        else:
9763 
          iprot.skip(ftype)
483 rajveer 9764 
      elif fid == 2:
9765 
        if ftype == TType.I64:
9766 
          self.from_date = iprot.readI64();
94 ashish 9767 
        else:
9768 
          iprot.skip(ftype)
483 rajveer 9769 
      elif fid == 3:
9770 
        if ftype == TType.I64:
9771 
          self.to_date = iprot.readI64();
94 ashish 9772 
        else:
9773 
          iprot.skip(ftype)
483 rajveer 9774 
      elif fid == 4:
94 ashish 9775 
        if ftype == TType.I64:
483 rajveer 9776 
          self.warehouse_id = iprot.readI64();
94 ashish 9777 
        else:
9778 
          iprot.skip(ftype)
9779 
      else:
9780 
        iprot.skip(ftype)
9781 
      iprot.readFieldEnd()
9782 
    iprot.readStructEnd()
9783 
 
9784 
  def write(self, oprot):
9785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9787 
      return
483 rajveer 9788 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9789 
    if self.statuses is not None:
9790 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9791 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9792 
      for iter126 in self.statuses:
9793 
        oprot.writeI32(iter126)
4801 anupam.sin 9794 
      oprot.writeListEnd()
94 ashish 9795 
      oprot.writeFieldEnd()
3431 rajveer 9796 
    if self.from_date is not None:
483 rajveer 9797 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9798 
      oprot.writeI64(self.from_date)
94 ashish 9799 
      oprot.writeFieldEnd()
3431 rajveer 9800 
    if self.to_date is not None:
483 rajveer 9801 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9802 
      oprot.writeI64(self.to_date)
94 ashish 9803 
      oprot.writeFieldEnd()
3431 rajveer 9804 
    if self.warehouse_id is not None:
483 rajveer 9805 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9806 
      oprot.writeI64(self.warehouse_id)
94 ashish 9807 
      oprot.writeFieldEnd()
9808 
    oprot.writeFieldStop()
9809 
    oprot.writeStructEnd()
9810 
 
3431 rajveer 9811 
  def validate(self):
9812 
    return
9813 
 
9814 
 
94 ashish 9815 
  def __repr__(self):
9816 
    L = ['%s=%r' % (key, value)
9817 
      for key, value in self.__dict__.iteritems()]
9818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9819 
 
9820 
  def __eq__(self, other):
9821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9822 
 
9823 
  def __ne__(self, other):
9824 
    return not (self == other)
9825 
 
483 rajveer 9826 
class getAllOrders_result:
94 ashish 9827 
  """
9828 
  Attributes:
9829 
   - success
9830 
   - ex
9831 
  """
9832 
 
9833 
  thrift_spec = (
483 rajveer 9834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9836 
  )
9837 
 
9838 
  def __init__(self, success=None, ex=None,):
9839 
    self.success = success
9840 
    self.ex = ex
9841 
 
9842 
  def read(self, iprot):
9843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9845 
      return
9846 
    iprot.readStructBegin()
9847 
    while True:
9848 
      (fname, ftype, fid) = iprot.readFieldBegin()
9849 
      if ftype == TType.STOP:
9850 
        break
9851 
      if fid == 0:
483 rajveer 9852 
        if ftype == TType.LIST:
9853 
          self.success = []
6188 rajveer 9854 
          (_etype130, _size127) = iprot.readListBegin()
9855 
          for _i131 in xrange(_size127):
9856 
            _elem132 = Order()
9857 
            _elem132.read(iprot)
9858 
            self.success.append(_elem132)
483 rajveer 9859 
          iprot.readListEnd()
94 ashish 9860 
        else:
9861 
          iprot.skip(ftype)
9862 
      elif fid == 1:
9863 
        if ftype == TType.STRUCT:
9864 
          self.ex = TransactionServiceException()
9865 
          self.ex.read(iprot)
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      else:
9869 
        iprot.skip(ftype)
9870 
      iprot.readFieldEnd()
9871 
    iprot.readStructEnd()
9872 
 
9873 
  def write(self, oprot):
9874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9876 
      return
483 rajveer 9877 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9878 
    if self.success is not None:
483 rajveer 9879 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9880 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9881 
      for iter133 in self.success:
9882 
        iter133.write(oprot)
483 rajveer 9883 
      oprot.writeListEnd()
94 ashish 9884 
      oprot.writeFieldEnd()
3431 rajveer 9885 
    if self.ex is not None:
94 ashish 9886 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9887 
      self.ex.write(oprot)
9888 
      oprot.writeFieldEnd()
9889 
    oprot.writeFieldStop()
9890 
    oprot.writeStructEnd()
9891 
 
3431 rajveer 9892 
  def validate(self):
9893 
    return
9894 
 
9895 
 
94 ashish 9896 
  def __repr__(self):
9897 
    L = ['%s=%r' % (key, value)
9898 
      for key, value in self.__dict__.iteritems()]
9899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9900 
 
9901 
  def __eq__(self, other):
9902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9903 
 
9904 
  def __ne__(self, other):
9905 
    return not (self == other)
9906 
 
4133 chandransh 9907 
class getOrdersInBatch_args:
9908 
  """
9909 
  Attributes:
9910 
   - statuses
9911 
   - offset
9912 
   - limit
9913 
   - warehouse_id
9914 
  """
9915 
 
9916 
  thrift_spec = (
9917 
    None, # 0
9918 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9919 
    (2, TType.I64, 'offset', None, None, ), # 2
9920 
    (3, TType.I64, 'limit', None, None, ), # 3
9921 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9922 
  )
9923 
 
9924 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9925 
    self.statuses = statuses
9926 
    self.offset = offset
9927 
    self.limit = limit
9928 
    self.warehouse_id = warehouse_id
9929 
 
9930 
  def read(self, iprot):
9931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9933 
      return
9934 
    iprot.readStructBegin()
9935 
    while True:
9936 
      (fname, ftype, fid) = iprot.readFieldBegin()
9937 
      if ftype == TType.STOP:
9938 
        break
9939 
      if fid == 1:
9940 
        if ftype == TType.LIST:
9941 
          self.statuses = []
6188 rajveer 9942 
          (_etype137, _size134) = iprot.readListBegin()
9943 
          for _i138 in xrange(_size134):
9944 
            _elem139 = iprot.readI32();
9945 
            self.statuses.append(_elem139)
4133 chandransh 9946 
          iprot.readListEnd()
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      elif fid == 2:
9950 
        if ftype == TType.I64:
9951 
          self.offset = iprot.readI64();
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      elif fid == 3:
9955 
        if ftype == TType.I64:
9956 
          self.limit = iprot.readI64();
9957 
        else:
9958 
          iprot.skip(ftype)
9959 
      elif fid == 4:
9960 
        if ftype == TType.I64:
9961 
          self.warehouse_id = iprot.readI64();
9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      else:
9965 
        iprot.skip(ftype)
9966 
      iprot.readFieldEnd()
9967 
    iprot.readStructEnd()
9968 
 
9969 
  def write(self, oprot):
9970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9972 
      return
9973 
    oprot.writeStructBegin('getOrdersInBatch_args')
9974 
    if self.statuses is not None:
9975 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9976 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9977 
      for iter140 in self.statuses:
9978 
        oprot.writeI32(iter140)
4133 chandransh 9979 
      oprot.writeListEnd()
9980 
      oprot.writeFieldEnd()
9981 
    if self.offset is not None:
9982 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9983 
      oprot.writeI64(self.offset)
9984 
      oprot.writeFieldEnd()
9985 
    if self.limit is not None:
9986 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9987 
      oprot.writeI64(self.limit)
9988 
      oprot.writeFieldEnd()
9989 
    if self.warehouse_id is not None:
9990 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9991 
      oprot.writeI64(self.warehouse_id)
9992 
      oprot.writeFieldEnd()
9993 
    oprot.writeFieldStop()
9994 
    oprot.writeStructEnd()
9995 
 
9996 
  def validate(self):
9997 
    return
9998 
 
9999 
 
10000 
  def __repr__(self):
10001 
    L = ['%s=%r' % (key, value)
10002 
      for key, value in self.__dict__.iteritems()]
10003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10004 
 
10005 
  def __eq__(self, other):
10006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10007 
 
10008 
  def __ne__(self, other):
10009 
    return not (self == other)
10010 
 
10011 
class getOrdersInBatch_result:
10012 
  """
10013 
  Attributes:
10014 
   - success
10015 
   - ex
10016 
  """
10017 
 
10018 
  thrift_spec = (
10019 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10021 
  )
10022 
 
10023 
  def __init__(self, success=None, ex=None,):
10024 
    self.success = success
10025 
    self.ex = ex
10026 
 
10027 
  def read(self, iprot):
10028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10030 
      return
10031 
    iprot.readStructBegin()
10032 
    while True:
10033 
      (fname, ftype, fid) = iprot.readFieldBegin()
10034 
      if ftype == TType.STOP:
10035 
        break
10036 
      if fid == 0:
10037 
        if ftype == TType.LIST:
10038 
          self.success = []
6188 rajveer 10039 
          (_etype144, _size141) = iprot.readListBegin()
10040 
          for _i145 in xrange(_size141):
10041 
            _elem146 = Order()
10042 
            _elem146.read(iprot)
10043 
            self.success.append(_elem146)
4133 chandransh 10044 
          iprot.readListEnd()
10045 
        else:
10046 
          iprot.skip(ftype)
10047 
      elif fid == 1:
10048 
        if ftype == TType.STRUCT:
10049 
          self.ex = TransactionServiceException()
10050 
          self.ex.read(iprot)
10051 
        else:
10052 
          iprot.skip(ftype)
10053 
      else:
10054 
        iprot.skip(ftype)
10055 
      iprot.readFieldEnd()
10056 
    iprot.readStructEnd()
10057 
 
10058 
  def write(self, oprot):
10059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10061 
      return
10062 
    oprot.writeStructBegin('getOrdersInBatch_result')
10063 
    if self.success is not None:
10064 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10065 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10066 
      for iter147 in self.success:
10067 
        iter147.write(oprot)
4133 chandransh 10068 
      oprot.writeListEnd()
10069 
      oprot.writeFieldEnd()
10070 
    if self.ex is not None:
10071 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10072 
      self.ex.write(oprot)
10073 
      oprot.writeFieldEnd()
10074 
    oprot.writeFieldStop()
10075 
    oprot.writeStructEnd()
10076 
 
10077 
  def validate(self):
10078 
    return
10079 
 
10080 
 
10081 
  def __repr__(self):
10082 
    L = ['%s=%r' % (key, value)
10083 
      for key, value in self.__dict__.iteritems()]
10084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10085 
 
10086 
  def __eq__(self, other):
10087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10088 
 
10089 
  def __ne__(self, other):
10090 
    return not (self == other)
10091 
 
10092 
class getOrderCount_args:
10093 
  """
10094 
  Attributes:
10095 
   - statuses
10096 
   - warehouseId
10097 
  """
10098 
 
10099 
  thrift_spec = (
10100 
    None, # 0
10101 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10102 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10103 
  )
10104 
 
10105 
  def __init__(self, statuses=None, warehouseId=None,):
10106 
    self.statuses = statuses
10107 
    self.warehouseId = warehouseId
10108 
 
10109 
  def read(self, iprot):
10110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10112 
      return
10113 
    iprot.readStructBegin()
10114 
    while True:
10115 
      (fname, ftype, fid) = iprot.readFieldBegin()
10116 
      if ftype == TType.STOP:
10117 
        break
10118 
      if fid == 1:
10119 
        if ftype == TType.LIST:
10120 
          self.statuses = []
6188 rajveer 10121 
          (_etype151, _size148) = iprot.readListBegin()
10122 
          for _i152 in xrange(_size148):
10123 
            _elem153 = iprot.readI32();
10124 
            self.statuses.append(_elem153)
4133 chandransh 10125 
          iprot.readListEnd()
10126 
        else:
10127 
          iprot.skip(ftype)
10128 
      elif fid == 2:
10129 
        if ftype == TType.I64:
10130 
          self.warehouseId = iprot.readI64();
10131 
        else:
10132 
          iprot.skip(ftype)
10133 
      else:
10134 
        iprot.skip(ftype)
10135 
      iprot.readFieldEnd()
10136 
    iprot.readStructEnd()
10137 
 
10138 
  def write(self, oprot):
10139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10141 
      return
10142 
    oprot.writeStructBegin('getOrderCount_args')
10143 
    if self.statuses is not None:
10144 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10145 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10146 
      for iter154 in self.statuses:
10147 
        oprot.writeI32(iter154)
4133 chandransh 10148 
      oprot.writeListEnd()
10149 
      oprot.writeFieldEnd()
10150 
    if self.warehouseId is not None:
10151 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10152 
      oprot.writeI64(self.warehouseId)
10153 
      oprot.writeFieldEnd()
10154 
    oprot.writeFieldStop()
10155 
    oprot.writeStructEnd()
10156 
 
10157 
  def validate(self):
10158 
    return
10159 
 
10160 
 
10161 
  def __repr__(self):
10162 
    L = ['%s=%r' % (key, value)
10163 
      for key, value in self.__dict__.iteritems()]
10164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10165 
 
10166 
  def __eq__(self, other):
10167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10168 
 
10169 
  def __ne__(self, other):
10170 
    return not (self == other)
10171 
 
10172 
class getOrderCount_result:
10173 
  """
10174 
  Attributes:
10175 
   - success
10176 
   - ex
10177 
  """
10178 
 
10179 
  thrift_spec = (
10180 
    (0, TType.I32, 'success', None, None, ), # 0
10181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10182 
  )
10183 
 
10184 
  def __init__(self, success=None, ex=None,):
10185 
    self.success = success
10186 
    self.ex = ex
10187 
 
10188 
  def read(self, iprot):
10189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10191 
      return
10192 
    iprot.readStructBegin()
10193 
    while True:
10194 
      (fname, ftype, fid) = iprot.readFieldBegin()
10195 
      if ftype == TType.STOP:
10196 
        break
10197 
      if fid == 0:
10198 
        if ftype == TType.I32:
10199 
          self.success = iprot.readI32();
10200 
        else:
10201 
          iprot.skip(ftype)
10202 
      elif fid == 1:
10203 
        if ftype == TType.STRUCT:
10204 
          self.ex = TransactionServiceException()
10205 
          self.ex.read(iprot)
10206 
        else:
10207 
          iprot.skip(ftype)
10208 
      else:
10209 
        iprot.skip(ftype)
10210 
      iprot.readFieldEnd()
10211 
    iprot.readStructEnd()
10212 
 
10213 
  def write(self, oprot):
10214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10216 
      return
10217 
    oprot.writeStructBegin('getOrderCount_result')
10218 
    if self.success is not None:
10219 
      oprot.writeFieldBegin('success', TType.I32, 0)
10220 
      oprot.writeI32(self.success)
10221 
      oprot.writeFieldEnd()
10222 
    if self.ex is not None:
10223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10224 
      self.ex.write(oprot)
10225 
      oprot.writeFieldEnd()
10226 
    oprot.writeFieldStop()
10227 
    oprot.writeStructEnd()
10228 
 
10229 
  def validate(self):
10230 
    return
10231 
 
10232 
 
10233 
  def __repr__(self):
10234 
    L = ['%s=%r' % (key, value)
10235 
      for key, value in self.__dict__.iteritems()]
10236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10237 
 
10238 
  def __eq__(self, other):
10239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10240 
 
10241 
  def __ne__(self, other):
10242 
    return not (self == other)
10243 
 
999 varun.gupt 10244 
class getOrdersByBillingDate_args:
10245 
  """
10246 
  Attributes:
10247 
   - status
10248 
   - start_billing_date
10249 
   - end_billing_date
10250 
   - warehouse_id
10251 
  """
10252 
 
10253 
  thrift_spec = (
10254 
    None, # 0
10255 
    (1, TType.I32, 'status', None, None, ), # 1
10256 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10257 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10258 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10259 
  )
10260 
 
10261 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10262 
    self.status = status
10263 
    self.start_billing_date = start_billing_date
10264 
    self.end_billing_date = end_billing_date
10265 
    self.warehouse_id = warehouse_id
10266 
 
10267 
  def read(self, iprot):
10268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10270 
      return
10271 
    iprot.readStructBegin()
10272 
    while True:
10273 
      (fname, ftype, fid) = iprot.readFieldBegin()
10274 
      if ftype == TType.STOP:
10275 
        break
10276 
      if fid == 1:
10277 
        if ftype == TType.I32:
10278 
          self.status = iprot.readI32();
10279 
        else:
10280 
          iprot.skip(ftype)
10281 
      elif fid == 2:
10282 
        if ftype == TType.I64:
10283 
          self.start_billing_date = iprot.readI64();
10284 
        else:
10285 
          iprot.skip(ftype)
10286 
      elif fid == 3:
10287 
        if ftype == TType.I64:
10288 
          self.end_billing_date = iprot.readI64();
10289 
        else:
10290 
          iprot.skip(ftype)
10291 
      elif fid == 4:
10292 
        if ftype == TType.I64:
10293 
          self.warehouse_id = iprot.readI64();
10294 
        else:
10295 
          iprot.skip(ftype)
10296 
      else:
10297 
        iprot.skip(ftype)
10298 
      iprot.readFieldEnd()
10299 
    iprot.readStructEnd()
10300 
 
10301 
  def write(self, oprot):
10302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10304 
      return
10305 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10306 
    if self.status is not None:
999 varun.gupt 10307 
      oprot.writeFieldBegin('status', TType.I32, 1)
10308 
      oprot.writeI32(self.status)
10309 
      oprot.writeFieldEnd()
3431 rajveer 10310 
    if self.start_billing_date is not None:
999 varun.gupt 10311 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10312 
      oprot.writeI64(self.start_billing_date)
10313 
      oprot.writeFieldEnd()
3431 rajveer 10314 
    if self.end_billing_date is not None:
999 varun.gupt 10315 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10316 
      oprot.writeI64(self.end_billing_date)
10317 
      oprot.writeFieldEnd()
3431 rajveer 10318 
    if self.warehouse_id is not None:
999 varun.gupt 10319 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10320 
      oprot.writeI64(self.warehouse_id)
10321 
      oprot.writeFieldEnd()
10322 
    oprot.writeFieldStop()
10323 
    oprot.writeStructEnd()
10324 
 
3431 rajveer 10325 
  def validate(self):
10326 
    return
10327 
 
10328 
 
999 varun.gupt 10329 
  def __repr__(self):
10330 
    L = ['%s=%r' % (key, value)
10331 
      for key, value in self.__dict__.iteritems()]
10332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10333 
 
10334 
  def __eq__(self, other):
10335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10336 
 
10337 
  def __ne__(self, other):
10338 
    return not (self == other)
10339 
 
10340 
class getOrdersByBillingDate_result:
10341 
  """
10342 
  Attributes:
10343 
   - success
10344 
   - ex
10345 
  """
10346 
 
10347 
  thrift_spec = (
10348 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10350 
  )
10351 
 
10352 
  def __init__(self, success=None, ex=None,):
10353 
    self.success = success
10354 
    self.ex = ex
10355 
 
10356 
  def read(self, iprot):
10357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10359 
      return
10360 
    iprot.readStructBegin()
10361 
    while True:
10362 
      (fname, ftype, fid) = iprot.readFieldBegin()
10363 
      if ftype == TType.STOP:
10364 
        break
10365 
      if fid == 0:
10366 
        if ftype == TType.LIST:
10367 
          self.success = []
6188 rajveer 10368 
          (_etype158, _size155) = iprot.readListBegin()
10369 
          for _i159 in xrange(_size155):
10370 
            _elem160 = Order()
10371 
            _elem160.read(iprot)
10372 
            self.success.append(_elem160)
999 varun.gupt 10373 
          iprot.readListEnd()
10374 
        else:
10375 
          iprot.skip(ftype)
10376 
      elif fid == 1:
10377 
        if ftype == TType.STRUCT:
10378 
          self.ex = TransactionServiceException()
10379 
          self.ex.read(iprot)
10380 
        else:
10381 
          iprot.skip(ftype)
10382 
      else:
10383 
        iprot.skip(ftype)
10384 
      iprot.readFieldEnd()
10385 
    iprot.readStructEnd()
10386 
 
10387 
  def write(self, oprot):
10388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10390 
      return
10391 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10392 
    if self.success is not None:
999 varun.gupt 10393 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10394 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10395 
      for iter161 in self.success:
10396 
        iter161.write(oprot)
999 varun.gupt 10397 
      oprot.writeListEnd()
10398 
      oprot.writeFieldEnd()
3431 rajveer 10399 
    if self.ex is not None:
999 varun.gupt 10400 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10401 
      self.ex.write(oprot)
10402 
      oprot.writeFieldEnd()
10403 
    oprot.writeFieldStop()
10404 
    oprot.writeStructEnd()
10405 
 
3431 rajveer 10406 
  def validate(self):
10407 
    return
10408 
 
10409 
 
999 varun.gupt 10410 
  def __repr__(self):
10411 
    L = ['%s=%r' % (key, value)
10412 
      for key, value in self.__dict__.iteritems()]
10413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10414 
 
10415 
  def __eq__(self, other):
10416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10417 
 
10418 
  def __ne__(self, other):
10419 
    return not (self == other)
10420 
 
3427 chandransh 10421 
class getOrdersByShippingDate_args:
10422 
  """
10423 
  Attributes:
10424 
   - fromShippingDate
10425 
   - toShippingDate
10426 
   - providerId
10427 
   - warehouseId
3451 chandransh 10428 
   - cod
3427 chandransh 10429 
  """
10430 
 
10431 
  thrift_spec = (
10432 
    None, # 0
10433 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10434 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10435 
    (3, TType.I64, 'providerId', None, None, ), # 3
10436 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10437 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10438 
  )
10439 
 
3451 chandransh 10440 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10441 
    self.fromShippingDate = fromShippingDate
10442 
    self.toShippingDate = toShippingDate
10443 
    self.providerId = providerId
10444 
    self.warehouseId = warehouseId
3451 chandransh 10445 
    self.cod = cod
3427 chandransh 10446 
 
10447 
  def read(self, iprot):
10448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10450 
      return
10451 
    iprot.readStructBegin()
10452 
    while True:
10453 
      (fname, ftype, fid) = iprot.readFieldBegin()
10454 
      if ftype == TType.STOP:
10455 
        break
10456 
      if fid == 1:
10457 
        if ftype == TType.I64:
10458 
          self.fromShippingDate = iprot.readI64();
10459 
        else:
10460 
          iprot.skip(ftype)
10461 
      elif fid == 2:
10462 
        if ftype == TType.I64:
10463 
          self.toShippingDate = iprot.readI64();
10464 
        else:
10465 
          iprot.skip(ftype)
10466 
      elif fid == 3:
10467 
        if ftype == TType.I64:
10468 
          self.providerId = iprot.readI64();
10469 
        else:
10470 
          iprot.skip(ftype)
10471 
      elif fid == 4:
10472 
        if ftype == TType.I64:
10473 
          self.warehouseId = iprot.readI64();
10474 
        else:
10475 
          iprot.skip(ftype)
3451 chandransh 10476 
      elif fid == 5:
10477 
        if ftype == TType.BOOL:
10478 
          self.cod = iprot.readBool();
10479 
        else:
10480 
          iprot.skip(ftype)
3427 chandransh 10481 
      else:
10482 
        iprot.skip(ftype)
10483 
      iprot.readFieldEnd()
10484 
    iprot.readStructEnd()
10485 
 
10486 
  def write(self, oprot):
10487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10489 
      return
10490 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10491 
    if self.fromShippingDate is not None:
3427 chandransh 10492 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10493 
      oprot.writeI64(self.fromShippingDate)
10494 
      oprot.writeFieldEnd()
3431 rajveer 10495 
    if self.toShippingDate is not None:
3427 chandransh 10496 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10497 
      oprot.writeI64(self.toShippingDate)
10498 
      oprot.writeFieldEnd()
3431 rajveer 10499 
    if self.providerId is not None:
3427 chandransh 10500 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10501 
      oprot.writeI64(self.providerId)
10502 
      oprot.writeFieldEnd()
3431 rajveer 10503 
    if self.warehouseId is not None:
3427 chandransh 10504 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10505 
      oprot.writeI64(self.warehouseId)
10506 
      oprot.writeFieldEnd()
3451 chandransh 10507 
    if self.cod is not None:
10508 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10509 
      oprot.writeBool(self.cod)
10510 
      oprot.writeFieldEnd()
3427 chandransh 10511 
    oprot.writeFieldStop()
10512 
    oprot.writeStructEnd()
10513 
 
3431 rajveer 10514 
  def validate(self):
10515 
    return
10516 
 
10517 
 
3427 chandransh 10518 
  def __repr__(self):
10519 
    L = ['%s=%r' % (key, value)
10520 
      for key, value in self.__dict__.iteritems()]
10521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10522 
 
10523 
  def __eq__(self, other):
10524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10525 
 
10526 
  def __ne__(self, other):
10527 
    return not (self == other)
10528 
 
10529 
class getOrdersByShippingDate_result:
10530 
  """
10531 
  Attributes:
10532 
   - success
10533 
   - ex
10534 
  """
10535 
 
10536 
  thrift_spec = (
10537 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10538 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10539 
  )
10540 
 
10541 
  def __init__(self, success=None, ex=None,):
10542 
    self.success = success
10543 
    self.ex = ex
10544 
 
10545 
  def read(self, iprot):
10546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10548 
      return
10549 
    iprot.readStructBegin()
10550 
    while True:
10551 
      (fname, ftype, fid) = iprot.readFieldBegin()
10552 
      if ftype == TType.STOP:
10553 
        break
10554 
      if fid == 0:
10555 
        if ftype == TType.LIST:
10556 
          self.success = []
6188 rajveer 10557 
          (_etype165, _size162) = iprot.readListBegin()
10558 
          for _i166 in xrange(_size162):
10559 
            _elem167 = Order()
10560 
            _elem167.read(iprot)
10561 
            self.success.append(_elem167)
3427 chandransh 10562 
          iprot.readListEnd()
10563 
        else:
10564 
          iprot.skip(ftype)
10565 
      elif fid == 1:
10566 
        if ftype == TType.STRUCT:
10567 
          self.ex = TransactionServiceException()
10568 
          self.ex.read(iprot)
10569 
        else:
10570 
          iprot.skip(ftype)
10571 
      else:
10572 
        iprot.skip(ftype)
10573 
      iprot.readFieldEnd()
10574 
    iprot.readStructEnd()
10575 
 
10576 
  def write(self, oprot):
10577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10579 
      return
10580 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10581 
    if self.success is not None:
3427 chandransh 10582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10583 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10584 
      for iter168 in self.success:
10585 
        iter168.write(oprot)
3427 chandransh 10586 
      oprot.writeListEnd()
10587 
      oprot.writeFieldEnd()
3431 rajveer 10588 
    if self.ex is not None:
3427 chandransh 10589 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10590 
      self.ex.write(oprot)
10591 
      oprot.writeFieldEnd()
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
3431 rajveer 10595 
  def validate(self):
10596 
    return
10597 
 
10598 
 
3427 chandransh 10599 
  def __repr__(self):
10600 
    L = ['%s=%r' % (key, value)
10601 
      for key, value in self.__dict__.iteritems()]
10602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10603 
 
10604 
  def __eq__(self, other):
10605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10606 
 
10607 
  def __ne__(self, other):
10608 
    return not (self == other)
10609 
 
1382 varun.gupt 10610 
class getReturnableOrdersForCustomer_args:
10611 
  """
10612 
  Attributes:
10613 
   - customer_id
10614 
   - limit
10615 
  """
10616 
 
10617 
  thrift_spec = (
10618 
    None, # 0
10619 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10620 
    (2, TType.I64, 'limit', None, None, ), # 2
10621 
  )
10622 
 
10623 
  def __init__(self, customer_id=None, limit=None,):
10624 
    self.customer_id = customer_id
10625 
    self.limit = limit
10626 
 
10627 
  def read(self, iprot):
10628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10630 
      return
10631 
    iprot.readStructBegin()
10632 
    while True:
10633 
      (fname, ftype, fid) = iprot.readFieldBegin()
10634 
      if ftype == TType.STOP:
10635 
        break
10636 
      if fid == 1:
10637 
        if ftype == TType.I64:
10638 
          self.customer_id = iprot.readI64();
10639 
        else:
10640 
          iprot.skip(ftype)
10641 
      elif fid == 2:
10642 
        if ftype == TType.I64:
10643 
          self.limit = iprot.readI64();
10644 
        else:
10645 
          iprot.skip(ftype)
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('getReturnableOrdersForCustomer_args')
3431 rajveer 10656 
    if self.customer_id is not None:
1382 varun.gupt 10657 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10658 
      oprot.writeI64(self.customer_id)
10659 
      oprot.writeFieldEnd()
3431 rajveer 10660 
    if self.limit is not None:
1382 varun.gupt 10661 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10662 
      oprot.writeI64(self.limit)
10663 
      oprot.writeFieldEnd()
10664 
    oprot.writeFieldStop()
10665 
    oprot.writeStructEnd()
10666 
 
3431 rajveer 10667 
  def validate(self):
10668 
    return
10669 
 
10670 
 
1382 varun.gupt 10671 
  def __repr__(self):
10672 
    L = ['%s=%r' % (key, value)
10673 
      for key, value in self.__dict__.iteritems()]
10674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10675 
 
10676 
  def __eq__(self, other):
10677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10678 
 
10679 
  def __ne__(self, other):
10680 
    return not (self == other)
10681 
 
10682 
class getReturnableOrdersForCustomer_result:
10683 
  """
10684 
  Attributes:
10685 
   - success
10686 
   - ex
10687 
  """
10688 
 
10689 
  thrift_spec = (
10690 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10692 
  )
10693 
 
10694 
  def __init__(self, success=None, ex=None,):
10695 
    self.success = success
10696 
    self.ex = ex
10697 
 
10698 
  def read(self, iprot):
10699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10701 
      return
10702 
    iprot.readStructBegin()
10703 
    while True:
10704 
      (fname, ftype, fid) = iprot.readFieldBegin()
10705 
      if ftype == TType.STOP:
10706 
        break
10707 
      if fid == 0:
10708 
        if ftype == TType.LIST:
10709 
          self.success = []
6188 rajveer 10710 
          (_etype172, _size169) = iprot.readListBegin()
10711 
          for _i173 in xrange(_size169):
10712 
            _elem174 = iprot.readI64();
10713 
            self.success.append(_elem174)
1382 varun.gupt 10714 
          iprot.readListEnd()
10715 
        else:
10716 
          iprot.skip(ftype)
10717 
      elif fid == 1:
10718 
        if ftype == TType.STRUCT:
10719 
          self.ex = TransactionServiceException()
10720 
          self.ex.read(iprot)
10721 
        else:
10722 
          iprot.skip(ftype)
10723 
      else:
10724 
        iprot.skip(ftype)
10725 
      iprot.readFieldEnd()
10726 
    iprot.readStructEnd()
10727 
 
10728 
  def write(self, oprot):
10729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10731 
      return
10732 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10733 
    if self.success is not None:
1382 varun.gupt 10734 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10735 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10736 
      for iter175 in self.success:
10737 
        oprot.writeI64(iter175)
1382 varun.gupt 10738 
      oprot.writeListEnd()
10739 
      oprot.writeFieldEnd()
3431 rajveer 10740 
    if self.ex is not None:
1382 varun.gupt 10741 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10742 
      self.ex.write(oprot)
10743 
      oprot.writeFieldEnd()
10744 
    oprot.writeFieldStop()
10745 
    oprot.writeStructEnd()
10746 
 
3431 rajveer 10747 
  def validate(self):
10748 
    return
10749 
 
10750 
 
1382 varun.gupt 10751 
  def __repr__(self):
10752 
    L = ['%s=%r' % (key, value)
10753 
      for key, value in self.__dict__.iteritems()]
10754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10755 
 
10756 
  def __eq__(self, other):
10757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10758 
 
10759 
  def __ne__(self, other):
10760 
    return not (self == other)
10761 
 
10762 
class getCancellableOrdersForCustomer_args:
10763 
  """
10764 
  Attributes:
10765 
   - customer_id
10766 
   - limit
10767 
  """
10768 
 
10769 
  thrift_spec = (
10770 
    None, # 0
10771 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10772 
    (2, TType.I64, 'limit', None, None, ), # 2
10773 
  )
10774 
 
10775 
  def __init__(self, customer_id=None, limit=None,):
10776 
    self.customer_id = customer_id
10777 
    self.limit = limit
10778 
 
10779 
  def read(self, iprot):
10780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10782 
      return
10783 
    iprot.readStructBegin()
10784 
    while True:
10785 
      (fname, ftype, fid) = iprot.readFieldBegin()
10786 
      if ftype == TType.STOP:
10787 
        break
10788 
      if fid == 1:
10789 
        if ftype == TType.I64:
10790 
          self.customer_id = iprot.readI64();
10791 
        else:
10792 
          iprot.skip(ftype)
10793 
      elif fid == 2:
10794 
        if ftype == TType.I64:
10795 
          self.limit = iprot.readI64();
10796 
        else:
10797 
          iprot.skip(ftype)
10798 
      else:
10799 
        iprot.skip(ftype)
10800 
      iprot.readFieldEnd()
10801 
    iprot.readStructEnd()
10802 
 
10803 
  def write(self, oprot):
10804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10806 
      return
10807 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10808 
    if self.customer_id is not None:
1382 varun.gupt 10809 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10810 
      oprot.writeI64(self.customer_id)
10811 
      oprot.writeFieldEnd()
3431 rajveer 10812 
    if self.limit is not None:
1382 varun.gupt 10813 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10814 
      oprot.writeI64(self.limit)
10815 
      oprot.writeFieldEnd()
10816 
    oprot.writeFieldStop()
10817 
    oprot.writeStructEnd()
10818 
 
3431 rajveer 10819 
  def validate(self):
10820 
    return
10821 
 
10822 
 
1382 varun.gupt 10823 
  def __repr__(self):
10824 
    L = ['%s=%r' % (key, value)
10825 
      for key, value in self.__dict__.iteritems()]
10826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10827 
 
10828 
  def __eq__(self, other):
10829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10830 
 
10831 
  def __ne__(self, other):
10832 
    return not (self == other)
10833 
 
10834 
class getCancellableOrdersForCustomer_result:
10835 
  """
10836 
  Attributes:
10837 
   - success
10838 
   - ex
10839 
  """
10840 
 
10841 
  thrift_spec = (
10842 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10843 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10844 
  )
10845 
 
10846 
  def __init__(self, success=None, ex=None,):
10847 
    self.success = success
10848 
    self.ex = ex
10849 
 
10850 
  def read(self, iprot):
10851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10853 
      return
10854 
    iprot.readStructBegin()
10855 
    while True:
10856 
      (fname, ftype, fid) = iprot.readFieldBegin()
10857 
      if ftype == TType.STOP:
10858 
        break
10859 
      if fid == 0:
10860 
        if ftype == TType.LIST:
10861 
          self.success = []
6188 rajveer 10862 
          (_etype179, _size176) = iprot.readListBegin()
10863 
          for _i180 in xrange(_size176):
10864 
            _elem181 = iprot.readI64();
10865 
            self.success.append(_elem181)
1382 varun.gupt 10866 
          iprot.readListEnd()
10867 
        else:
10868 
          iprot.skip(ftype)
10869 
      elif fid == 1:
10870 
        if ftype == TType.STRUCT:
10871 
          self.ex = TransactionServiceException()
10872 
          self.ex.read(iprot)
10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      else:
10876 
        iprot.skip(ftype)
10877 
      iprot.readFieldEnd()
10878 
    iprot.readStructEnd()
10879 
 
10880 
  def write(self, oprot):
10881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10883 
      return
10884 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10885 
    if self.success is not None:
1382 varun.gupt 10886 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10887 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10888 
      for iter182 in self.success:
10889 
        oprot.writeI64(iter182)
1382 varun.gupt 10890 
      oprot.writeListEnd()
10891 
      oprot.writeFieldEnd()
3431 rajveer 10892 
    if self.ex is not None:
1382 varun.gupt 10893 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10894 
      self.ex.write(oprot)
10895 
      oprot.writeFieldEnd()
10896 
    oprot.writeFieldStop()
10897 
    oprot.writeStructEnd()
10898 
 
3431 rajveer 10899 
  def validate(self):
10900 
    return
10901 
 
10902 
 
1382 varun.gupt 10903 
  def __repr__(self):
10904 
    L = ['%s=%r' % (key, value)
10905 
      for key, value in self.__dict__.iteritems()]
10906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10907 
 
10908 
  def __eq__(self, other):
10909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10910 
 
10911 
  def __ne__(self, other):
10912 
    return not (self == other)
10913 
 
483 rajveer 10914 
class changeOrderStatus_args:
94 ashish 10915 
  """
10916 
  Attributes:
483 rajveer 10917 
   - orderId
10918 
   - status
10919 
   - description
94 ashish 10920 
  """
10921 
 
10922 
  thrift_spec = (
10923 
    None, # 0
483 rajveer 10924 
    (1, TType.I64, 'orderId', None, None, ), # 1
10925 
    (2, TType.I32, 'status', None, None, ), # 2
10926 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10927 
  )
10928 
 
483 rajveer 10929 
  def __init__(self, orderId=None, status=None, description=None,):
10930 
    self.orderId = orderId
10931 
    self.status = status
10932 
    self.description = description
94 ashish 10933 
 
10934 
  def read(self, iprot):
10935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10937 
      return
10938 
    iprot.readStructBegin()
10939 
    while True:
10940 
      (fname, ftype, fid) = iprot.readFieldBegin()
10941 
      if ftype == TType.STOP:
10942 
        break
10943 
      if fid == 1:
10944 
        if ftype == TType.I64:
483 rajveer 10945 
          self.orderId = iprot.readI64();
94 ashish 10946 
        else:
10947 
          iprot.skip(ftype)
10948 
      elif fid == 2:
483 rajveer 10949 
        if ftype == TType.I32:
10950 
          self.status = iprot.readI32();
94 ashish 10951 
        else:
10952 
          iprot.skip(ftype)
483 rajveer 10953 
      elif fid == 3:
10954 
        if ftype == TType.STRING:
10955 
          self.description = iprot.readString();
10956 
        else:
10957 
          iprot.skip(ftype)
94 ashish 10958 
      else:
10959 
        iprot.skip(ftype)
10960 
      iprot.readFieldEnd()
10961 
    iprot.readStructEnd()
10962 
 
10963 
  def write(self, oprot):
10964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10966 
      return
483 rajveer 10967 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10968 
    if self.orderId is not None:
483 rajveer 10969 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10970 
      oprot.writeI64(self.orderId)
94 ashish 10971 
      oprot.writeFieldEnd()
3431 rajveer 10972 
    if self.status is not None:
483 rajveer 10973 
      oprot.writeFieldBegin('status', TType.I32, 2)
10974 
      oprot.writeI32(self.status)
94 ashish 10975 
      oprot.writeFieldEnd()
3431 rajveer 10976 
    if self.description is not None:
483 rajveer 10977 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10978 
      oprot.writeString(self.description)
10979 
      oprot.writeFieldEnd()
94 ashish 10980 
    oprot.writeFieldStop()
10981 
    oprot.writeStructEnd()
10982 
 
3431 rajveer 10983 
  def validate(self):
10984 
    return
10985 
 
10986 
 
94 ashish 10987 
  def __repr__(self):
10988 
    L = ['%s=%r' % (key, value)
10989 
      for key, value in self.__dict__.iteritems()]
10990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10991 
 
10992 
  def __eq__(self, other):
10993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10994 
 
10995 
  def __ne__(self, other):
10996 
    return not (self == other)
10997 
 
483 rajveer 10998 
class changeOrderStatus_result:
94 ashish 10999 
  """
11000 
  Attributes:
11001 
   - success
11002 
   - ex
11003 
  """
11004 
 
11005 
  thrift_spec = (
11006 
    (0, TType.BOOL, 'success', None, None, ), # 0
11007 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11008 
  )
11009 
 
11010 
  def __init__(self, success=None, ex=None,):
11011 
    self.success = success
11012 
    self.ex = ex
11013 
 
11014 
  def read(self, iprot):
11015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11017 
      return
11018 
    iprot.readStructBegin()
11019 
    while True:
11020 
      (fname, ftype, fid) = iprot.readFieldBegin()
11021 
      if ftype == TType.STOP:
11022 
        break
11023 
      if fid == 0:
11024 
        if ftype == TType.BOOL:
11025 
          self.success = iprot.readBool();
11026 
        else:
11027 
          iprot.skip(ftype)
11028 
      elif fid == 1:
11029 
        if ftype == TType.STRUCT:
11030 
          self.ex = TransactionServiceException()
11031 
          self.ex.read(iprot)
11032 
        else:
11033 
          iprot.skip(ftype)
11034 
      else:
11035 
        iprot.skip(ftype)
11036 
      iprot.readFieldEnd()
11037 
    iprot.readStructEnd()
11038 
 
11039 
  def write(self, oprot):
11040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11042 
      return
483 rajveer 11043 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11044 
    if self.success is not None:
94 ashish 11045 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11046 
      oprot.writeBool(self.success)
11047 
      oprot.writeFieldEnd()
3431 rajveer 11048 
    if self.ex is not None:
94 ashish 11049 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11050 
      self.ex.write(oprot)
11051 
      oprot.writeFieldEnd()
11052 
    oprot.writeFieldStop()
11053 
    oprot.writeStructEnd()
11054 
 
3431 rajveer 11055 
  def validate(self):
11056 
    return
11057 
 
11058 
 
94 ashish 11059 
  def __repr__(self):
11060 
    L = ['%s=%r' % (key, value)
11061 
      for key, value in self.__dict__.iteritems()]
11062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11063 
 
11064 
  def __eq__(self, other):
11065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11066 
 
11067 
  def __ne__(self, other):
11068 
    return not (self == other)
11069 
 
3064 chandransh 11070 
class getOrdersForTransaction_args:
494 rajveer 11071 
  """
11072 
  Attributes:
3064 chandransh 11073 
   - transactionId
11074 
   - customerId
494 rajveer 11075 
  """
11076 
 
11077 
  thrift_spec = (
11078 
    None, # 0
3064 chandransh 11079 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11080 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11081 
  )
11082 
 
3064 chandransh 11083 
  def __init__(self, transactionId=None, customerId=None,):
11084 
    self.transactionId = transactionId
11085 
    self.customerId = customerId
494 rajveer 11086 
 
11087 
  def read(self, iprot):
11088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11090 
      return
11091 
    iprot.readStructBegin()
11092 
    while True:
11093 
      (fname, ftype, fid) = iprot.readFieldBegin()
11094 
      if ftype == TType.STOP:
11095 
        break
11096 
      if fid == 1:
11097 
        if ftype == TType.I64:
3064 chandransh 11098 
          self.transactionId = iprot.readI64();
494 rajveer 11099 
        else:
11100 
          iprot.skip(ftype)
11101 
      elif fid == 2:
3064 chandransh 11102 
        if ftype == TType.I64:
11103 
          self.customerId = iprot.readI64();
494 rajveer 11104 
        else:
11105 
          iprot.skip(ftype)
11106 
      else:
11107 
        iprot.skip(ftype)
11108 
      iprot.readFieldEnd()
11109 
    iprot.readStructEnd()
11110 
 
11111 
  def write(self, oprot):
11112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11114 
      return
3064 chandransh 11115 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11116 
    if self.transactionId is not None:
3064 chandransh 11117 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11118 
      oprot.writeI64(self.transactionId)
494 rajveer 11119 
      oprot.writeFieldEnd()
3431 rajveer 11120 
    if self.customerId is not None:
3064 chandransh 11121 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11122 
      oprot.writeI64(self.customerId)
494 rajveer 11123 
      oprot.writeFieldEnd()
11124 
    oprot.writeFieldStop()
11125 
    oprot.writeStructEnd()
11126 
 
3431 rajveer 11127 
  def validate(self):
11128 
    return
11129 
 
11130 
 
494 rajveer 11131 
  def __repr__(self):
11132 
    L = ['%s=%r' % (key, value)
11133 
      for key, value in self.__dict__.iteritems()]
11134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11135 
 
11136 
  def __eq__(self, other):
11137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11138 
 
11139 
  def __ne__(self, other):
11140 
    return not (self == other)
11141 
 
3064 chandransh 11142 
class getOrdersForTransaction_result:
494 rajveer 11143 
  """
11144 
  Attributes:
11145 
   - success
11146 
   - ex
11147 
  """
11148 
 
11149 
  thrift_spec = (
3064 chandransh 11150 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11151 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11152 
  )
11153 
 
11154 
  def __init__(self, success=None, ex=None,):
11155 
    self.success = success
11156 
    self.ex = ex
11157 
 
11158 
  def read(self, iprot):
11159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11161 
      return
11162 
    iprot.readStructBegin()
11163 
    while True:
11164 
      (fname, ftype, fid) = iprot.readFieldBegin()
11165 
      if ftype == TType.STOP:
11166 
        break
11167 
      if fid == 0:
3064 chandransh 11168 
        if ftype == TType.LIST:
11169 
          self.success = []
6188 rajveer 11170 
          (_etype186, _size183) = iprot.readListBegin()
11171 
          for _i187 in xrange(_size183):
11172 
            _elem188 = Order()
11173 
            _elem188.read(iprot)
11174 
            self.success.append(_elem188)
3064 chandransh 11175 
          iprot.readListEnd()
494 rajveer 11176 
        else:
11177 
          iprot.skip(ftype)
11178 
      elif fid == 1:
11179 
        if ftype == TType.STRUCT:
11180 
          self.ex = TransactionServiceException()
11181 
          self.ex.read(iprot)
11182 
        else:
11183 
          iprot.skip(ftype)
11184 
      else:
11185 
        iprot.skip(ftype)
11186 
      iprot.readFieldEnd()
11187 
    iprot.readStructEnd()
11188 
 
11189 
  def write(self, oprot):
11190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11192 
      return
3064 chandransh 11193 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11194 
    if self.success is not None:
3064 chandransh 11195 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11196 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11197 
      for iter189 in self.success:
11198 
        iter189.write(oprot)
3064 chandransh 11199 
      oprot.writeListEnd()
494 rajveer 11200 
      oprot.writeFieldEnd()
3431 rajveer 11201 
    if self.ex is not None:
494 rajveer 11202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11203 
      self.ex.write(oprot)
11204 
      oprot.writeFieldEnd()
11205 
    oprot.writeFieldStop()
11206 
    oprot.writeStructEnd()
11207 
 
3431 rajveer 11208 
  def validate(self):
11209 
    return
11210 
 
11211 
 
494 rajveer 11212 
  def __repr__(self):
11213 
    L = ['%s=%r' % (key, value)
11214 
      for key, value in self.__dict__.iteritems()]
11215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11216 
 
11217 
  def __eq__(self, other):
11218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11219 
 
11220 
  def __ne__(self, other):
11221 
    return not (self == other)
11222 
 
3064 chandransh 11223 
class getOrdersForCustomer_args:
1149 chandransh 11224 
  """
11225 
  Attributes:
3064 chandransh 11226 
   - customerId
11227 
   - from_date
11228 
   - to_date
11229 
   - statuses
1149 chandransh 11230 
  """
11231 
 
11232 
  thrift_spec = (
11233 
    None, # 0
3064 chandransh 11234 
    (1, TType.I64, 'customerId', None, None, ), # 1
11235 
    (2, TType.I64, 'from_date', None, None, ), # 2
11236 
    (3, TType.I64, 'to_date', None, None, ), # 3
11237 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11238 
  )
11239 
 
3064 chandransh 11240 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11241 
    self.customerId = customerId
11242 
    self.from_date = from_date
11243 
    self.to_date = to_date
11244 
    self.statuses = statuses
1149 chandransh 11245 
 
11246 
  def read(self, iprot):
11247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11249 
      return
11250 
    iprot.readStructBegin()
11251 
    while True:
11252 
      (fname, ftype, fid) = iprot.readFieldBegin()
11253 
      if ftype == TType.STOP:
11254 
        break
11255 
      if fid == 1:
11256 
        if ftype == TType.I64:
3064 chandransh 11257 
          self.customerId = iprot.readI64();
1149 chandransh 11258 
        else:
11259 
          iprot.skip(ftype)
11260 
      elif fid == 2:
11261 
        if ftype == TType.I64:
3064 chandransh 11262 
          self.from_date = iprot.readI64();
1149 chandransh 11263 
        else:
11264 
          iprot.skip(ftype)
2783 chandransh 11265 
      elif fid == 3:
11266 
        if ftype == TType.I64:
3064 chandransh 11267 
          self.to_date = iprot.readI64();
2783 chandransh 11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      elif fid == 4:
3064 chandransh 11271 
        if ftype == TType.LIST:
11272 
          self.statuses = []
6188 rajveer 11273 
          (_etype193, _size190) = iprot.readListBegin()
11274 
          for _i194 in xrange(_size190):
11275 
            _elem195 = iprot.readI32();
11276 
            self.statuses.append(_elem195)
3064 chandransh 11277 
          iprot.readListEnd()
2783 chandransh 11278 
        else:
11279 
          iprot.skip(ftype)
1149 chandransh 11280 
      else:
11281 
        iprot.skip(ftype)
11282 
      iprot.readFieldEnd()
11283 
    iprot.readStructEnd()
11284 
 
11285 
  def write(self, oprot):
11286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11288 
      return
3064 chandransh 11289 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11290 
    if self.customerId is not None:
3064 chandransh 11291 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11292 
      oprot.writeI64(self.customerId)
1149 chandransh 11293 
      oprot.writeFieldEnd()
3431 rajveer 11294 
    if self.from_date is not None:
3064 chandransh 11295 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11296 
      oprot.writeI64(self.from_date)
1149 chandransh 11297 
      oprot.writeFieldEnd()
3431 rajveer 11298 
    if self.to_date is not None:
3064 chandransh 11299 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11300 
      oprot.writeI64(self.to_date)
2783 chandransh 11301 
      oprot.writeFieldEnd()
3431 rajveer 11302 
    if self.statuses is not None:
3064 chandransh 11303 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11304 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11305 
      for iter196 in self.statuses:
11306 
        oprot.writeI32(iter196)
3064 chandransh 11307 
      oprot.writeListEnd()
2783 chandransh 11308 
      oprot.writeFieldEnd()
1149 chandransh 11309 
    oprot.writeFieldStop()
11310 
    oprot.writeStructEnd()
11311 
 
3431 rajveer 11312 
  def validate(self):
11313 
    return
11314 
 
11315 
 
1149 chandransh 11316 
  def __repr__(self):
11317 
    L = ['%s=%r' % (key, value)
11318 
      for key, value in self.__dict__.iteritems()]
11319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11320 
 
11321 
  def __eq__(self, other):
11322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11323 
 
11324 
  def __ne__(self, other):
11325 
    return not (self == other)
11326 
 
3064 chandransh 11327 
class getOrdersForCustomer_result:
1149 chandransh 11328 
  """
11329 
  Attributes:
11330 
   - success
11331 
   - ex
11332 
  """
11333 
 
11334 
  thrift_spec = (
3064 chandransh 11335 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11337 
  )
11338 
 
11339 
  def __init__(self, success=None, ex=None,):
11340 
    self.success = success
11341 
    self.ex = ex
11342 
 
11343 
  def read(self, iprot):
11344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11346 
      return
11347 
    iprot.readStructBegin()
11348 
    while True:
11349 
      (fname, ftype, fid) = iprot.readFieldBegin()
11350 
      if ftype == TType.STOP:
11351 
        break
11352 
      if fid == 0:
3064 chandransh 11353 
        if ftype == TType.LIST:
11354 
          self.success = []
6188 rajveer 11355 
          (_etype200, _size197) = iprot.readListBegin()
11356 
          for _i201 in xrange(_size197):
11357 
            _elem202 = Order()
11358 
            _elem202.read(iprot)
11359 
            self.success.append(_elem202)
3064 chandransh 11360 
          iprot.readListEnd()
1149 chandransh 11361 
        else:
11362 
          iprot.skip(ftype)
11363 
      elif fid == 1:
11364 
        if ftype == TType.STRUCT:
11365 
          self.ex = TransactionServiceException()
11366 
          self.ex.read(iprot)
11367 
        else:
11368 
          iprot.skip(ftype)
11369 
      else:
11370 
        iprot.skip(ftype)
11371 
      iprot.readFieldEnd()
11372 
    iprot.readStructEnd()
11373 
 
11374 
  def write(self, oprot):
11375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11377 
      return
3064 chandransh 11378 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11379 
    if self.success is not None:
3064 chandransh 11380 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11381 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11382 
      for iter203 in self.success:
11383 
        iter203.write(oprot)
3064 chandransh 11384 
      oprot.writeListEnd()
1149 chandransh 11385 
      oprot.writeFieldEnd()
3431 rajveer 11386 
    if self.ex is not None:
1149 chandransh 11387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11388 
      self.ex.write(oprot)
11389 
      oprot.writeFieldEnd()
11390 
    oprot.writeFieldStop()
11391 
    oprot.writeStructEnd()
11392 
 
3431 rajveer 11393 
  def validate(self):
11394 
    return
11395 
 
11396 
 
1149 chandransh 11397 
  def __repr__(self):
11398 
    L = ['%s=%r' % (key, value)
11399 
      for key, value in self.__dict__.iteritems()]
11400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11401 
 
11402 
  def __eq__(self, other):
11403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11404 
 
11405 
  def __ne__(self, other):
11406 
    return not (self == other)
11407 
 
3064 chandransh 11408 
class createOrder_args:
921 rajveer 11409 
  """
11410 
  Attributes:
3064 chandransh 11411 
   - order
921 rajveer 11412 
  """
11413 
 
11414 
  thrift_spec = (
11415 
    None, # 0
3064 chandransh 11416 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11417 
  )
11418 
 
3064 chandransh 11419 
  def __init__(self, order=None,):
11420 
    self.order = order
921 rajveer 11421 
 
11422 
  def read(self, iprot):
11423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11425 
      return
11426 
    iprot.readStructBegin()
11427 
    while True:
11428 
      (fname, ftype, fid) = iprot.readFieldBegin()
11429 
      if ftype == TType.STOP:
11430 
        break
11431 
      if fid == 1:
3064 chandransh 11432 
        if ftype == TType.STRUCT:
11433 
          self.order = Order()
11434 
          self.order.read(iprot)
921 rajveer 11435 
        else:
11436 
          iprot.skip(ftype)
11437 
      else:
11438 
        iprot.skip(ftype)
11439 
      iprot.readFieldEnd()
11440 
    iprot.readStructEnd()
11441 
 
11442 
  def write(self, oprot):
11443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11445 
      return
3064 chandransh 11446 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11447 
    if self.order is not None:
3064 chandransh 11448 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11449 
      self.order.write(oprot)
921 rajveer 11450 
      oprot.writeFieldEnd()
11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
3431 rajveer 11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
921 rajveer 11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
3064 chandransh 11469 
class createOrder_result:
921 rajveer 11470 
  """
11471 
  Attributes:
11472 
   - success
11473 
   - ex
11474 
  """
11475 
 
11476 
  thrift_spec = (
3064 chandransh 11477 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11478 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11479 
  )
11480 
 
11481 
  def __init__(self, success=None, ex=None,):
11482 
    self.success = success
11483 
    self.ex = ex
11484 
 
11485 
  def read(self, iprot):
11486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11488 
      return
11489 
    iprot.readStructBegin()
11490 
    while True:
11491 
      (fname, ftype, fid) = iprot.readFieldBegin()
11492 
      if ftype == TType.STOP:
11493 
        break
11494 
      if fid == 0:
3064 chandransh 11495 
        if ftype == TType.I64:
11496 
          self.success = iprot.readI64();
921 rajveer 11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      elif fid == 1:
11500 
        if ftype == TType.STRUCT:
11501 
          self.ex = TransactionServiceException()
11502 
          self.ex.read(iprot)
11503 
        else:
11504 
          iprot.skip(ftype)
11505 
      else:
11506 
        iprot.skip(ftype)
11507 
      iprot.readFieldEnd()
11508 
    iprot.readStructEnd()
11509 
 
11510 
  def write(self, oprot):
11511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11513 
      return
3064 chandransh 11514 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11515 
    if self.success is not None:
3064 chandransh 11516 
      oprot.writeFieldBegin('success', TType.I64, 0)
11517 
      oprot.writeI64(self.success)
921 rajveer 11518 
      oprot.writeFieldEnd()
3431 rajveer 11519 
    if self.ex is not None:
921 rajveer 11520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11521 
      self.ex.write(oprot)
11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
921 rajveer 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
3064 chandransh 11541 
class getOrder_args:
921 rajveer 11542 
  """
11543 
  Attributes:
3064 chandransh 11544 
   - id
921 rajveer 11545 
  """
11546 
 
11547 
  thrift_spec = (
11548 
    None, # 0
3064 chandransh 11549 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11550 
  )
11551 
 
3064 chandransh 11552 
  def __init__(self, id=None,):
11553 
    self.id = id
921 rajveer 11554 
 
11555 
  def read(self, iprot):
11556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11558 
      return
11559 
    iprot.readStructBegin()
11560 
    while True:
11561 
      (fname, ftype, fid) = iprot.readFieldBegin()
11562 
      if ftype == TType.STOP:
11563 
        break
11564 
      if fid == 1:
11565 
        if ftype == TType.I64:
3064 chandransh 11566 
          self.id = iprot.readI64();
921 rajveer 11567 
        else:
11568 
          iprot.skip(ftype)
11569 
      else:
11570 
        iprot.skip(ftype)
11571 
      iprot.readFieldEnd()
11572 
    iprot.readStructEnd()
11573 
 
11574 
  def write(self, oprot):
11575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11577 
      return
3064 chandransh 11578 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11579 
    if self.id is not None:
3064 chandransh 11580 
      oprot.writeFieldBegin('id', TType.I64, 1)
11581 
      oprot.writeI64(self.id)
921 rajveer 11582 
      oprot.writeFieldEnd()
11583 
    oprot.writeFieldStop()
11584 
    oprot.writeStructEnd()
11585 
 
3431 rajveer 11586 
  def validate(self):
11587 
    return
11588 
 
11589 
 
921 rajveer 11590 
  def __repr__(self):
11591 
    L = ['%s=%r' % (key, value)
11592 
      for key, value in self.__dict__.iteritems()]
11593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11594 
 
11595 
  def __eq__(self, other):
11596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11597 
 
11598 
  def __ne__(self, other):
11599 
    return not (self == other)
11600 
 
3064 chandransh 11601 
class getOrder_result:
921 rajveer 11602 
  """
11603 
  Attributes:
11604 
   - success
11605 
   - ex
11606 
  """
11607 
 
11608 
  thrift_spec = (
3064 chandransh 11609 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11611 
  )
11612 
 
11613 
  def __init__(self, success=None, ex=None,):
11614 
    self.success = success
11615 
    self.ex = ex
11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      if fid == 0:
3064 chandransh 11627 
        if ftype == TType.STRUCT:
11628 
          self.success = Order()
11629 
          self.success.read(iprot)
921 rajveer 11630 
        else:
11631 
          iprot.skip(ftype)
11632 
      elif fid == 1:
11633 
        if ftype == TType.STRUCT:
11634 
          self.ex = TransactionServiceException()
11635 
          self.ex.read(iprot)
11636 
        else:
11637 
          iprot.skip(ftype)
11638 
      else:
11639 
        iprot.skip(ftype)
11640 
      iprot.readFieldEnd()
11641 
    iprot.readStructEnd()
11642 
 
11643 
  def write(self, oprot):
11644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11646 
      return
3064 chandransh 11647 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11648 
    if self.success is not None:
3064 chandransh 11649 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11650 
      self.success.write(oprot)
921 rajveer 11651 
      oprot.writeFieldEnd()
3431 rajveer 11652 
    if self.ex is not None:
921 rajveer 11653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11654 
      self.ex.write(oprot)
11655 
      oprot.writeFieldEnd()
11656 
    oprot.writeFieldStop()
11657 
    oprot.writeStructEnd()
11658 
 
3431 rajveer 11659 
  def validate(self):
11660 
    return
11661 
 
11662 
 
921 rajveer 11663 
  def __repr__(self):
11664 
    L = ['%s=%r' % (key, value)
11665 
      for key, value in self.__dict__.iteritems()]
11666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11667 
 
11668 
  def __eq__(self, other):
11669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11670 
 
11671 
  def __ne__(self, other):
11672 
    return not (self == other)
11673 
 
3064 chandransh 11674 
class getLineItemsForOrder_args:
94 ashish 11675 
  """
11676 
  Attributes:
3064 chandransh 11677 
   - orderId
94 ashish 11678 
  """
11679 
 
11680 
  thrift_spec = (
11681 
    None, # 0
3064 chandransh 11682 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11683 
  )
11684 
 
3064 chandransh 11685 
  def __init__(self, orderId=None,):
11686 
    self.orderId = orderId
94 ashish 11687 
 
11688 
  def read(self, iprot):
11689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11691 
      return
11692 
    iprot.readStructBegin()
11693 
    while True:
11694 
      (fname, ftype, fid) = iprot.readFieldBegin()
11695 
      if ftype == TType.STOP:
11696 
        break
11697 
      if fid == 1:
11698 
        if ftype == TType.I64:
3064 chandransh 11699 
          self.orderId = iprot.readI64();
94 ashish 11700 
        else:
11701 
          iprot.skip(ftype)
11702 
      else:
11703 
        iprot.skip(ftype)
11704 
      iprot.readFieldEnd()
11705 
    iprot.readStructEnd()
11706 
 
11707 
  def write(self, oprot):
11708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11710 
      return
3064 chandransh 11711 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11712 
    if self.orderId is not None:
3064 chandransh 11713 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11714 
      oprot.writeI64(self.orderId)
94 ashish 11715 
      oprot.writeFieldEnd()
11716 
    oprot.writeFieldStop()
11717 
    oprot.writeStructEnd()
11718 
 
3431 rajveer 11719 
  def validate(self):
11720 
    return
11721 
 
11722 
 
94 ashish 11723 
  def __repr__(self):
11724 
    L = ['%s=%r' % (key, value)
11725 
      for key, value in self.__dict__.iteritems()]
11726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11727 
 
11728 
  def __eq__(self, other):
11729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11730 
 
11731 
  def __ne__(self, other):
11732 
    return not (self == other)
11733 
 
3064 chandransh 11734 
class getLineItemsForOrder_result:
94 ashish 11735 
  """
11736 
  Attributes:
11737 
   - success
11738 
   - ex
11739 
  """
11740 
 
11741 
  thrift_spec = (
3064 chandransh 11742 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11744 
  )
11745 
 
11746 
  def __init__(self, success=None, ex=None,):
11747 
    self.success = success
11748 
    self.ex = ex
11749 
 
11750 
  def read(self, iprot):
11751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11753 
      return
11754 
    iprot.readStructBegin()
11755 
    while True:
11756 
      (fname, ftype, fid) = iprot.readFieldBegin()
11757 
      if ftype == TType.STOP:
11758 
        break
11759 
      if fid == 0:
483 rajveer 11760 
        if ftype == TType.LIST:
11761 
          self.success = []
6188 rajveer 11762 
          (_etype207, _size204) = iprot.readListBegin()
11763 
          for _i208 in xrange(_size204):
11764 
            _elem209 = LineItem()
11765 
            _elem209.read(iprot)
11766 
            self.success.append(_elem209)
483 rajveer 11767 
          iprot.readListEnd()
94 ashish 11768 
        else:
11769 
          iprot.skip(ftype)
11770 
      elif fid == 1:
11771 
        if ftype == TType.STRUCT:
11772 
          self.ex = TransactionServiceException()
11773 
          self.ex.read(iprot)
11774 
        else:
11775 
          iprot.skip(ftype)
11776 
      else:
11777 
        iprot.skip(ftype)
11778 
      iprot.readFieldEnd()
11779 
    iprot.readStructEnd()
11780 
 
11781 
  def write(self, oprot):
11782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11784 
      return
3064 chandransh 11785 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11786 
    if self.success is not None:
483 rajveer 11787 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11788 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11789 
      for iter210 in self.success:
11790 
        iter210.write(oprot)
483 rajveer 11791 
      oprot.writeListEnd()
94 ashish 11792 
      oprot.writeFieldEnd()
3431 rajveer 11793 
    if self.ex is not None:
94 ashish 11794 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11795 
      self.ex.write(oprot)
11796 
      oprot.writeFieldEnd()
11797 
    oprot.writeFieldStop()
11798 
    oprot.writeStructEnd()
11799 
 
3431 rajveer 11800 
  def validate(self):
11801 
    return
11802 
 
11803 
 
94 ashish 11804 
  def __repr__(self):
11805 
    L = ['%s=%r' % (key, value)
11806 
      for key, value in self.__dict__.iteritems()]
11807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11808 
 
11809 
  def __eq__(self, other):
11810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11811 
 
11812 
  def __ne__(self, other):
11813 
    return not (self == other)
11814 
 
4999 phani.kuma 11815 
class getOrderList_args:
11816 
  """
11817 
  Attributes:
11818 
   - order_ids
11819 
  """
11820 
 
11821 
  thrift_spec = (
11822 
    None, # 0
11823 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11824 
  )
11825 
 
11826 
  def __init__(self, order_ids=None,):
11827 
    self.order_ids = order_ids
11828 
 
11829 
  def read(self, iprot):
11830 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11831 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11832 
      return
11833 
    iprot.readStructBegin()
11834 
    while True:
11835 
      (fname, ftype, fid) = iprot.readFieldBegin()
11836 
      if ftype == TType.STOP:
11837 
        break
11838 
      if fid == 1:
11839 
        if ftype == TType.LIST:
11840 
          self.order_ids = []
6188 rajveer 11841 
          (_etype214, _size211) = iprot.readListBegin()
11842 
          for _i215 in xrange(_size211):
11843 
            _elem216 = iprot.readI64();
11844 
            self.order_ids.append(_elem216)
4999 phani.kuma 11845 
          iprot.readListEnd()
11846 
        else:
11847 
          iprot.skip(ftype)
11848 
      else:
11849 
        iprot.skip(ftype)
11850 
      iprot.readFieldEnd()
11851 
    iprot.readStructEnd()
11852 
 
11853 
  def write(self, oprot):
11854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11856 
      return
11857 
    oprot.writeStructBegin('getOrderList_args')
11858 
    if self.order_ids is not None:
11859 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11860 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11861 
      for iter217 in self.order_ids:
11862 
        oprot.writeI64(iter217)
4999 phani.kuma 11863 
      oprot.writeListEnd()
11864 
      oprot.writeFieldEnd()
11865 
    oprot.writeFieldStop()
11866 
    oprot.writeStructEnd()
11867 
 
11868 
  def validate(self):
11869 
    return
11870 
 
11871 
 
11872 
  def __repr__(self):
11873 
    L = ['%s=%r' % (key, value)
11874 
      for key, value in self.__dict__.iteritems()]
11875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11876 
 
11877 
  def __eq__(self, other):
11878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11879 
 
11880 
  def __ne__(self, other):
11881 
    return not (self == other)
11882 
 
11883 
class getOrderList_result:
11884 
  """
11885 
  Attributes:
11886 
   - success
11887 
  """
11888 
 
11889 
  thrift_spec = (
11890 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11891 
  )
11892 
 
11893 
  def __init__(self, success=None,):
11894 
    self.success = success
11895 
 
11896 
  def read(self, iprot):
11897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11899 
      return
11900 
    iprot.readStructBegin()
11901 
    while True:
11902 
      (fname, ftype, fid) = iprot.readFieldBegin()
11903 
      if ftype == TType.STOP:
11904 
        break
11905 
      if fid == 0:
11906 
        if ftype == TType.LIST:
11907 
          self.success = []
6188 rajveer 11908 
          (_etype221, _size218) = iprot.readListBegin()
11909 
          for _i222 in xrange(_size218):
11910 
            _elem223 = Order()
11911 
            _elem223.read(iprot)
11912 
            self.success.append(_elem223)
4999 phani.kuma 11913 
          iprot.readListEnd()
11914 
        else:
11915 
          iprot.skip(ftype)
11916 
      else:
11917 
        iprot.skip(ftype)
11918 
      iprot.readFieldEnd()
11919 
    iprot.readStructEnd()
11920 
 
11921 
  def write(self, oprot):
11922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11924 
      return
11925 
    oprot.writeStructBegin('getOrderList_result')
11926 
    if self.success is not None:
11927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11929 
      for iter224 in self.success:
11930 
        iter224.write(oprot)
4999 phani.kuma 11931 
      oprot.writeListEnd()
11932 
      oprot.writeFieldEnd()
11933 
    oprot.writeFieldStop()
11934 
    oprot.writeStructEnd()
11935 
 
11936 
  def validate(self):
11937 
    return
11938 
 
11939 
 
11940 
  def __repr__(self):
11941 
    L = ['%s=%r' % (key, value)
11942 
      for key, value in self.__dict__.iteritems()]
11943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11944 
 
11945 
  def __eq__(self, other):
11946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11947 
 
11948 
  def __ne__(self, other):
11949 
    return not (self == other)
11950 
 
5386 phani.kuma 11951 
class getOrderListForVendor_args:
11952 
  """
11953 
  Attributes:
11954 
   - order_ids
11955 
   - vendorId
11956 
  """
11957 
 
11958 
  thrift_spec = (
11959 
    None, # 0
11960 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11961 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11962 
  )
11963 
 
11964 
  def __init__(self, order_ids=None, vendorId=None,):
11965 
    self.order_ids = order_ids
11966 
    self.vendorId = vendorId
11967 
 
11968 
  def read(self, iprot):
11969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11971 
      return
11972 
    iprot.readStructBegin()
11973 
    while True:
11974 
      (fname, ftype, fid) = iprot.readFieldBegin()
11975 
      if ftype == TType.STOP:
11976 
        break
11977 
      if fid == 1:
11978 
        if ftype == TType.LIST:
11979 
          self.order_ids = []
6188 rajveer 11980 
          (_etype228, _size225) = iprot.readListBegin()
11981 
          for _i229 in xrange(_size225):
11982 
            _elem230 = iprot.readI64();
11983 
            self.order_ids.append(_elem230)
5386 phani.kuma 11984 
          iprot.readListEnd()
11985 
        else:
11986 
          iprot.skip(ftype)
11987 
      elif fid == 2:
11988 
        if ftype == TType.I64:
11989 
          self.vendorId = iprot.readI64();
11990 
        else:
11991 
          iprot.skip(ftype)
11992 
      else:
11993 
        iprot.skip(ftype)
11994 
      iprot.readFieldEnd()
11995 
    iprot.readStructEnd()
11996 
 
11997 
  def write(self, oprot):
11998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12000 
      return
12001 
    oprot.writeStructBegin('getOrderListForVendor_args')
12002 
    if self.order_ids is not None:
12003 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12004 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12005 
      for iter231 in self.order_ids:
12006 
        oprot.writeI64(iter231)
5386 phani.kuma 12007 
      oprot.writeListEnd()
12008 
      oprot.writeFieldEnd()
12009 
    if self.vendorId is not None:
12010 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12011 
      oprot.writeI64(self.vendorId)
12012 
      oprot.writeFieldEnd()
12013 
    oprot.writeFieldStop()
12014 
    oprot.writeStructEnd()
12015 
 
12016 
  def validate(self):
12017 
    return
12018 
 
12019 
 
12020 
  def __repr__(self):
12021 
    L = ['%s=%r' % (key, value)
12022 
      for key, value in self.__dict__.iteritems()]
12023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12024 
 
12025 
  def __eq__(self, other):
12026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12027 
 
12028 
  def __ne__(self, other):
12029 
    return not (self == other)
12030 
 
12031 
class getOrderListForVendor_result:
12032 
  """
12033 
  Attributes:
12034 
   - success
12035 
  """
12036 
 
12037 
  thrift_spec = (
12038 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12039 
  )
12040 
 
12041 
  def __init__(self, success=None,):
12042 
    self.success = success
12043 
 
12044 
  def read(self, iprot):
12045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12047 
      return
12048 
    iprot.readStructBegin()
12049 
    while True:
12050 
      (fname, ftype, fid) = iprot.readFieldBegin()
12051 
      if ftype == TType.STOP:
12052 
        break
12053 
      if fid == 0:
12054 
        if ftype == TType.LIST:
12055 
          self.success = []
6188 rajveer 12056 
          (_etype235, _size232) = iprot.readListBegin()
12057 
          for _i236 in xrange(_size232):
12058 
            _elem237 = Order()
12059 
            _elem237.read(iprot)
12060 
            self.success.append(_elem237)
5386 phani.kuma 12061 
          iprot.readListEnd()
12062 
        else:
12063 
          iprot.skip(ftype)
12064 
      else:
12065 
        iprot.skip(ftype)
12066 
      iprot.readFieldEnd()
12067 
    iprot.readStructEnd()
12068 
 
12069 
  def write(self, oprot):
12070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12072 
      return
12073 
    oprot.writeStructBegin('getOrderListForVendor_result')
12074 
    if self.success is not None:
12075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12076 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12077 
      for iter238 in self.success:
12078 
        iter238.write(oprot)
5386 phani.kuma 12079 
      oprot.writeListEnd()
12080 
      oprot.writeFieldEnd()
12081 
    oprot.writeFieldStop()
12082 
    oprot.writeStructEnd()
12083 
 
12084 
  def validate(self):
12085 
    return
12086 
 
12087 
 
12088 
  def __repr__(self):
12089 
    L = ['%s=%r' % (key, value)
12090 
      for key, value in self.__dict__.iteritems()]
12091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12092 
 
12093 
  def __eq__(self, other):
12094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12095 
 
12096 
  def __ne__(self, other):
12097 
    return not (self == other)
12098 
 
3064 chandransh 12099 
class getOrderForCustomer_args:
94 ashish 12100 
  """
12101 
  Attributes:
3064 chandransh 12102 
   - orderId
483 rajveer 12103 
   - customerId
94 ashish 12104 
  """
12105 
 
12106 
  thrift_spec = (
12107 
    None, # 0
3064 chandransh 12108 
    (1, TType.I64, 'orderId', None, None, ), # 1
12109 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12110 
  )
12111 
 
3064 chandransh 12112 
  def __init__(self, orderId=None, customerId=None,):
12113 
    self.orderId = orderId
483 rajveer 12114 
    self.customerId = customerId
94 ashish 12115 
 
12116 
  def read(self, iprot):
12117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12119 
      return
12120 
    iprot.readStructBegin()
12121 
    while True:
12122 
      (fname, ftype, fid) = iprot.readFieldBegin()
12123 
      if ftype == TType.STOP:
12124 
        break
12125 
      if fid == 1:
12126 
        if ftype == TType.I64:
3064 chandransh 12127 
          self.orderId = iprot.readI64();
94 ashish 12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      elif fid == 2:
12131 
        if ftype == TType.I64:
3064 chandransh 12132 
          self.customerId = iprot.readI64();
94 ashish 12133 
        else:
12134 
          iprot.skip(ftype)
12135 
      else:
12136 
        iprot.skip(ftype)
12137 
      iprot.readFieldEnd()
12138 
    iprot.readStructEnd()
12139 
 
12140 
  def write(self, oprot):
12141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12143 
      return
3064 chandransh 12144 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12145 
    if self.orderId is not None:
3064 chandransh 12146 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12147 
      oprot.writeI64(self.orderId)
12148 
      oprot.writeFieldEnd()
3431 rajveer 12149 
    if self.customerId is not None:
3064 chandransh 12150 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12151 
      oprot.writeI64(self.customerId)
94 ashish 12152 
      oprot.writeFieldEnd()
12153 
    oprot.writeFieldStop()
12154 
    oprot.writeStructEnd()
12155 
 
3431 rajveer 12156 
  def validate(self):
12157 
    return
12158 
 
12159 
 
94 ashish 12160 
  def __repr__(self):
12161 
    L = ['%s=%r' % (key, value)
12162 
      for key, value in self.__dict__.iteritems()]
12163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12164 
 
12165 
  def __eq__(self, other):
12166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12167 
 
12168 
  def __ne__(self, other):
12169 
    return not (self == other)
12170 
 
3064 chandransh 12171 
class getOrderForCustomer_result:
94 ashish 12172 
  """
12173 
  Attributes:
12174 
   - success
12175 
   - ex
12176 
  """
12177 
 
12178 
  thrift_spec = (
3064 chandransh 12179 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12181 
  )
12182 
 
12183 
  def __init__(self, success=None, ex=None,):
12184 
    self.success = success
12185 
    self.ex = ex
12186 
 
12187 
  def read(self, iprot):
12188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12190 
      return
12191 
    iprot.readStructBegin()
12192 
    while True:
12193 
      (fname, ftype, fid) = iprot.readFieldBegin()
12194 
      if ftype == TType.STOP:
12195 
        break
12196 
      if fid == 0:
3064 chandransh 12197 
        if ftype == TType.STRUCT:
12198 
          self.success = Order()
12199 
          self.success.read(iprot)
94 ashish 12200 
        else:
12201 
          iprot.skip(ftype)
12202 
      elif fid == 1:
12203 
        if ftype == TType.STRUCT:
12204 
          self.ex = TransactionServiceException()
12205 
          self.ex.read(iprot)
12206 
        else:
12207 
          iprot.skip(ftype)
12208 
      else:
12209 
        iprot.skip(ftype)
12210 
      iprot.readFieldEnd()
12211 
    iprot.readStructEnd()
12212 
 
12213 
  def write(self, oprot):
12214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12216 
      return
3064 chandransh 12217 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12218 
    if self.success is not None:
3064 chandransh 12219 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12220 
      self.success.write(oprot)
94 ashish 12221 
      oprot.writeFieldEnd()
3431 rajveer 12222 
    if self.ex is not None:
94 ashish 12223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12224 
      self.ex.write(oprot)
12225 
      oprot.writeFieldEnd()
12226 
    oprot.writeFieldStop()
12227 
    oprot.writeStructEnd()
12228 
 
3431 rajveer 12229 
  def validate(self):
12230 
    return
12231 
 
12232 
 
94 ashish 12233 
  def __repr__(self):
12234 
    L = ['%s=%r' % (key, value)
12235 
      for key, value in self.__dict__.iteritems()]
12236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12237 
 
12238 
  def __eq__(self, other):
12239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12240 
 
12241 
  def __ne__(self, other):
12242 
    return not (self == other)
12243 
 
3064 chandransh 12244 
class getAlerts_args:
94 ashish 12245 
  """
12246 
  Attributes:
4394 rajveer 12247 
   - type
4444 rajveer 12248 
   - warehouseId
4394 rajveer 12249 
   - status
12250 
   - timestamp
94 ashish 12251 
  """
12252 
 
12253 
  thrift_spec = (
12254 
    None, # 0
4394 rajveer 12255 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12256 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12257 
    (3, TType.I64, 'status', None, None, ), # 3
12258 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12259 
  )
12260 
 
4444 rajveer 12261 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12262 
    self.type = type
4444 rajveer 12263 
    self.warehouseId = warehouseId
4394 rajveer 12264 
    self.status = status
12265 
    self.timestamp = timestamp
94 ashish 12266 
 
12267 
  def read(self, iprot):
12268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12270 
      return
12271 
    iprot.readStructBegin()
12272 
    while True:
12273 
      (fname, ftype, fid) = iprot.readFieldBegin()
12274 
      if ftype == TType.STOP:
12275 
        break
12276 
      if fid == 1:
3064 chandransh 12277 
        if ftype == TType.I64:
4394 rajveer 12278 
          self.type = iprot.readI64();
94 ashish 12279 
        else:
12280 
          iprot.skip(ftype)
3064 chandransh 12281 
      elif fid == 2:
4394 rajveer 12282 
        if ftype == TType.I64:
4444 rajveer 12283 
          self.warehouseId = iprot.readI64();
3064 chandransh 12284 
        else:
12285 
          iprot.skip(ftype)
4394 rajveer 12286 
      elif fid == 3:
12287 
        if ftype == TType.I64:
4444 rajveer 12288 
          self.status = iprot.readI64();
12289 
        else:
12290 
          iprot.skip(ftype)
12291 
      elif fid == 4:
12292 
        if ftype == TType.I64:
4394 rajveer 12293 
          self.timestamp = iprot.readI64();
12294 
        else:
12295 
          iprot.skip(ftype)
94 ashish 12296 
      else:
12297 
        iprot.skip(ftype)
12298 
      iprot.readFieldEnd()
12299 
    iprot.readStructEnd()
12300 
 
12301 
  def write(self, oprot):
12302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12304 
      return
3064 chandransh 12305 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12306 
    if self.type is not None:
12307 
      oprot.writeFieldBegin('type', TType.I64, 1)
12308 
      oprot.writeI64(self.type)
94 ashish 12309 
      oprot.writeFieldEnd()
4444 rajveer 12310 
    if self.warehouseId is not None:
12311 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12312 
      oprot.writeI64(self.warehouseId)
12313 
      oprot.writeFieldEnd()
4394 rajveer 12314 
    if self.status is not None:
4444 rajveer 12315 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12316 
      oprot.writeI64(self.status)
3064 chandransh 12317 
      oprot.writeFieldEnd()
4394 rajveer 12318 
    if self.timestamp is not None:
4444 rajveer 12319 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12320 
      oprot.writeI64(self.timestamp)
12321 
      oprot.writeFieldEnd()
94 ashish 12322 
    oprot.writeFieldStop()
12323 
    oprot.writeStructEnd()
12324 
 
3431 rajveer 12325 
  def validate(self):
12326 
    return
12327 
 
12328 
 
94 ashish 12329 
  def __repr__(self):
12330 
    L = ['%s=%r' % (key, value)
12331 
      for key, value in self.__dict__.iteritems()]
12332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12333 
 
12334 
  def __eq__(self, other):
12335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12336 
 
12337 
  def __ne__(self, other):
12338 
    return not (self == other)
12339 
 
3064 chandransh 12340 
class getAlerts_result:
94 ashish 12341 
  """
12342 
  Attributes:
12343 
   - success
12344 
  """
12345 
 
12346 
  thrift_spec = (
3064 chandransh 12347 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12348 
  )
12349 
 
3064 chandransh 12350 
  def __init__(self, success=None,):
94 ashish 12351 
    self.success = success
12352 
 
12353 
  def read(self, iprot):
12354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12356 
      return
12357 
    iprot.readStructBegin()
12358 
    while True:
12359 
      (fname, ftype, fid) = iprot.readFieldBegin()
12360 
      if ftype == TType.STOP:
12361 
        break
12362 
      if fid == 0:
3064 chandransh 12363 
        if ftype == TType.LIST:
12364 
          self.success = []
6188 rajveer 12365 
          (_etype242, _size239) = iprot.readListBegin()
12366 
          for _i243 in xrange(_size239):
12367 
            _elem244 = Alert()
12368 
            _elem244.read(iprot)
12369 
            self.success.append(_elem244)
3064 chandransh 12370 
          iprot.readListEnd()
94 ashish 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('getAlerts_result')
3431 rajveer 12383 
    if self.success is not None:
3064 chandransh 12384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12386 
      for iter245 in self.success:
12387 
        iter245.write(oprot)
3064 chandransh 12388 
      oprot.writeListEnd()
94 ashish 12389 
      oprot.writeFieldEnd()
12390 
    oprot.writeFieldStop()
12391 
    oprot.writeStructEnd()
12392 
 
3431 rajveer 12393 
  def validate(self):
12394 
    return
12395 
 
12396 
 
94 ashish 12397 
  def __repr__(self):
12398 
    L = ['%s=%r' % (key, value)
12399 
      for key, value in self.__dict__.iteritems()]
12400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12401 
 
12402 
  def __eq__(self, other):
12403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12404 
 
12405 
  def __ne__(self, other):
12406 
    return not (self == other)
12407 
 
4394 rajveer 12408 
class addAlert_args:
94 ashish 12409 
  """
12410 
  Attributes:
3064 chandransh 12411 
   - type
4444 rajveer 12412 
   - warehouseId
4394 rajveer 12413 
   - description
94 ashish 12414 
  """
12415 
 
12416 
  thrift_spec = (
12417 
    None, # 0
4394 rajveer 12418 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12419 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12420 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12421 
  )
12422 
 
4444 rajveer 12423 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12424 
    self.type = type
4444 rajveer 12425 
    self.warehouseId = warehouseId
4394 rajveer 12426 
    self.description = description
94 ashish 12427 
 
12428 
  def read(self, iprot):
12429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12431 
      return
12432 
    iprot.readStructBegin()
12433 
    while True:
12434 
      (fname, ftype, fid) = iprot.readFieldBegin()
12435 
      if ftype == TType.STOP:
12436 
        break
12437 
      if fid == 1:
12438 
        if ftype == TType.I64:
4394 rajveer 12439 
          self.type = iprot.readI64();
94 ashish 12440 
        else:
12441 
          iprot.skip(ftype)
3064 chandransh 12442 
      elif fid == 2:
4444 rajveer 12443 
        if ftype == TType.I64:
12444 
          self.warehouseId = iprot.readI64();
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      elif fid == 3:
3064 chandransh 12448 
        if ftype == TType.STRING:
4394 rajveer 12449 
          self.description = iprot.readString();
3064 chandransh 12450 
        else:
12451 
          iprot.skip(ftype)
94 ashish 12452 
      else:
12453 
        iprot.skip(ftype)
12454 
      iprot.readFieldEnd()
12455 
    iprot.readStructEnd()
12456 
 
12457 
  def write(self, oprot):
12458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12460 
      return
4394 rajveer 12461 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12462 
    if self.type is not None:
4394 rajveer 12463 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12464 
      oprot.writeI64(self.type)
12465 
      oprot.writeFieldEnd()
4444 rajveer 12466 
    if self.warehouseId is not None:
12467 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12468 
      oprot.writeI64(self.warehouseId)
12469 
      oprot.writeFieldEnd()
4394 rajveer 12470 
    if self.description is not None:
4444 rajveer 12471 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12472 
      oprot.writeString(self.description)
3064 chandransh 12473 
      oprot.writeFieldEnd()
94 ashish 12474 
    oprot.writeFieldStop()
12475 
    oprot.writeStructEnd()
12476 
 
3431 rajveer 12477 
  def validate(self):
12478 
    return
12479 
 
12480 
 
94 ashish 12481 
  def __repr__(self):
12482 
    L = ['%s=%r' % (key, value)
12483 
      for key, value in self.__dict__.iteritems()]
12484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12485 
 
12486 
  def __eq__(self, other):
12487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12488 
 
12489 
  def __ne__(self, other):
12490 
    return not (self == other)
12491 
 
4394 rajveer 12492 
class addAlert_result:
3064 chandransh 12493 
 
12494 
  thrift_spec = (
12495 
  )
12496 
 
12497 
  def read(self, iprot):
12498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12500 
      return
12501 
    iprot.readStructBegin()
12502 
    while True:
12503 
      (fname, ftype, fid) = iprot.readFieldBegin()
12504 
      if ftype == TType.STOP:
12505 
        break
12506 
      else:
12507 
        iprot.skip(ftype)
12508 
      iprot.readFieldEnd()
12509 
    iprot.readStructEnd()
12510 
 
12511 
  def write(self, oprot):
12512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12514 
      return
4394 rajveer 12515 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12516 
    oprot.writeFieldStop()
12517 
    oprot.writeStructEnd()
12518 
 
3431 rajveer 12519 
  def validate(self):
12520 
    return
12521 
 
12522 
 
3064 chandransh 12523 
  def __repr__(self):
12524 
    L = ['%s=%r' % (key, value)
12525 
      for key, value in self.__dict__.iteritems()]
12526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12527 
 
12528 
  def __eq__(self, other):
12529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12530 
 
12531 
  def __ne__(self, other):
12532 
    return not (self == other)
12533 
 
4444 rajveer 12534 
class markAlertsAsSeen_args:
12535 
  """
12536 
  Attributes:
12537 
   - warehouseId
12538 
  """
12539 
 
12540 
  thrift_spec = (
12541 
    None, # 0
12542 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12543 
  )
12544 
 
12545 
  def __init__(self, warehouseId=None,):
12546 
    self.warehouseId = warehouseId
12547 
 
12548 
  def read(self, iprot):
12549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12551 
      return
12552 
    iprot.readStructBegin()
12553 
    while True:
12554 
      (fname, ftype, fid) = iprot.readFieldBegin()
12555 
      if ftype == TType.STOP:
12556 
        break
12557 
      if fid == 1:
12558 
        if ftype == TType.I64:
12559 
          self.warehouseId = iprot.readI64();
12560 
        else:
12561 
          iprot.skip(ftype)
12562 
      else:
12563 
        iprot.skip(ftype)
12564 
      iprot.readFieldEnd()
12565 
    iprot.readStructEnd()
12566 
 
12567 
  def write(self, oprot):
12568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12570 
      return
12571 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12572 
    if self.warehouseId is not None:
12573 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12574 
      oprot.writeI64(self.warehouseId)
12575 
      oprot.writeFieldEnd()
12576 
    oprot.writeFieldStop()
12577 
    oprot.writeStructEnd()
12578 
 
12579 
  def validate(self):
12580 
    return
12581 
 
12582 
 
12583 
  def __repr__(self):
12584 
    L = ['%s=%r' % (key, value)
12585 
      for key, value in self.__dict__.iteritems()]
12586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12587 
 
12588 
  def __eq__(self, other):
12589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12590 
 
12591 
  def __ne__(self, other):
12592 
    return not (self == other)
12593 
 
12594 
class markAlertsAsSeen_result:
12595 
 
12596 
  thrift_spec = (
12597 
  )
12598 
 
12599 
  def read(self, iprot):
12600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12602 
      return
12603 
    iprot.readStructBegin()
12604 
    while True:
12605 
      (fname, ftype, fid) = iprot.readFieldBegin()
12606 
      if ftype == TType.STOP:
12607 
        break
12608 
      else:
12609 
        iprot.skip(ftype)
12610 
      iprot.readFieldEnd()
12611 
    iprot.readStructEnd()
12612 
 
12613 
  def write(self, oprot):
12614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12616 
      return
12617 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12618 
    oprot.writeFieldStop()
12619 
    oprot.writeStructEnd()
12620 
 
12621 
  def validate(self):
12622 
    return
12623 
 
12624 
 
12625 
  def __repr__(self):
12626 
    L = ['%s=%r' % (key, value)
12627 
      for key, value in self.__dict__.iteritems()]
12628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12629 
 
12630 
  def __eq__(self, other):
12631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12632 
 
12633 
  def __ne__(self, other):
12634 
    return not (self == other)
12635 
 
3064 chandransh 12636 
class getValidOrderCount_args:
12637 
 
12638 
  thrift_spec = (
12639 
  )
12640 
 
12641 
  def read(self, iprot):
12642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12644 
      return
12645 
    iprot.readStructBegin()
12646 
    while True:
12647 
      (fname, ftype, fid) = iprot.readFieldBegin()
12648 
      if ftype == TType.STOP:
12649 
        break
12650 
      else:
12651 
        iprot.skip(ftype)
12652 
      iprot.readFieldEnd()
12653 
    iprot.readStructEnd()
12654 
 
12655 
  def write(self, oprot):
12656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12658 
      return
12659 
    oprot.writeStructBegin('getValidOrderCount_args')
12660 
    oprot.writeFieldStop()
12661 
    oprot.writeStructEnd()
12662 
 
3431 rajveer 12663 
  def validate(self):
12664 
    return
12665 
 
12666 
 
3064 chandransh 12667 
  def __repr__(self):
12668 
    L = ['%s=%r' % (key, value)
12669 
      for key, value in self.__dict__.iteritems()]
12670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12671 
 
12672 
  def __eq__(self, other):
12673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12674 
 
12675 
  def __ne__(self, other):
12676 
    return not (self == other)
12677 
 
12678 
class getValidOrderCount_result:
94 ashish 12679 
  """
12680 
  Attributes:
12681 
   - success
12682 
  """
12683 
 
12684 
  thrift_spec = (
3064 chandransh 12685 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12686 
  )
12687 
 
3064 chandransh 12688 
  def __init__(self, success=None,):
94 ashish 12689 
    self.success = success
12690 
 
12691 
  def read(self, iprot):
12692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12694 
      return
12695 
    iprot.readStructBegin()
12696 
    while True:
12697 
      (fname, ftype, fid) = iprot.readFieldBegin()
12698 
      if ftype == TType.STOP:
12699 
        break
12700 
      if fid == 0:
3064 chandransh 12701 
        if ftype == TType.I64:
12702 
          self.success = iprot.readI64();
94 ashish 12703 
        else:
12704 
          iprot.skip(ftype)
12705 
      else:
12706 
        iprot.skip(ftype)
12707 
      iprot.readFieldEnd()
12708 
    iprot.readStructEnd()
12709 
 
12710 
  def write(self, oprot):
12711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12713 
      return
3064 chandransh 12714 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12715 
    if self.success is not None:
3064 chandransh 12716 
      oprot.writeFieldBegin('success', TType.I64, 0)
12717 
      oprot.writeI64(self.success)
94 ashish 12718 
      oprot.writeFieldEnd()
12719 
    oprot.writeFieldStop()
12720 
    oprot.writeStructEnd()
12721 
 
3431 rajveer 12722 
  def validate(self):
12723 
    return
12724 
 
12725 
 
94 ashish 12726 
  def __repr__(self):
12727 
    L = ['%s=%r' % (key, value)
12728 
      for key, value in self.__dict__.iteritems()]
12729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12730 
 
12731 
  def __eq__(self, other):
12732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12733 
 
12734 
  def __ne__(self, other):
12735 
    return not (self == other)
12736 
 
3064 chandransh 12737 
class getNoOfCustomersWithSuccessfulTransaction_args:
12738 
 
12739 
  thrift_spec = (
12740 
  )
12741 
 
12742 
  def read(self, iprot):
12743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12745 
      return
12746 
    iprot.readStructBegin()
12747 
    while True:
12748 
      (fname, ftype, fid) = iprot.readFieldBegin()
12749 
      if ftype == TType.STOP:
12750 
        break
12751 
      else:
12752 
        iprot.skip(ftype)
12753 
      iprot.readFieldEnd()
12754 
    iprot.readStructEnd()
12755 
 
12756 
  def write(self, oprot):
12757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12759 
      return
12760 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12761 
    oprot.writeFieldStop()
12762 
    oprot.writeStructEnd()
12763 
 
3431 rajveer 12764 
  def validate(self):
12765 
    return
12766 
 
12767 
 
3064 chandransh 12768 
  def __repr__(self):
12769 
    L = ['%s=%r' % (key, value)
12770 
      for key, value in self.__dict__.iteritems()]
12771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12772 
 
12773 
  def __eq__(self, other):
12774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12775 
 
12776 
  def __ne__(self, other):
12777 
    return not (self == other)
12778 
 
12779 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12780 
  """
12781 
  Attributes:
3064 chandransh 12782 
   - success
94 ashish 12783 
  """
12784 
 
12785 
  thrift_spec = (
3064 chandransh 12786 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12787 
  )
12788 
 
3064 chandransh 12789 
  def __init__(self, success=None,):
12790 
    self.success = success
94 ashish 12791 
 
12792 
  def read(self, iprot):
12793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12795 
      return
12796 
    iprot.readStructBegin()
12797 
    while True:
12798 
      (fname, ftype, fid) = iprot.readFieldBegin()
12799 
      if ftype == TType.STOP:
12800 
        break
3064 chandransh 12801 
      if fid == 0:
94 ashish 12802 
        if ftype == TType.I64:
3064 chandransh 12803 
          self.success = iprot.readI64();
94 ashish 12804 
        else:
12805 
          iprot.skip(ftype)
12806 
      else:
12807 
        iprot.skip(ftype)
12808 
      iprot.readFieldEnd()
12809 
    iprot.readStructEnd()
12810 
 
12811 
  def write(self, oprot):
12812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12814 
      return
3064 chandransh 12815 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12816 
    if self.success is not None:
3064 chandransh 12817 
      oprot.writeFieldBegin('success', TType.I64, 0)
12818 
      oprot.writeI64(self.success)
94 ashish 12819 
      oprot.writeFieldEnd()
12820 
    oprot.writeFieldStop()
12821 
    oprot.writeStructEnd()
12822 
 
3431 rajveer 12823 
  def validate(self):
12824 
    return
12825 
 
12826 
 
94 ashish 12827 
  def __repr__(self):
12828 
    L = ['%s=%r' % (key, value)
12829 
      for key, value in self.__dict__.iteritems()]
12830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12831 
 
12832 
  def __eq__(self, other):
12833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12834 
 
12835 
  def __ne__(self, other):
12836 
    return not (self == other)
12837 
 
3064 chandransh 12838 
class getValidOrdersAmountRange_args:
12839 
 
12840 
  thrift_spec = (
12841 
  )
12842 
 
12843 
  def read(self, iprot):
12844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12846 
      return
12847 
    iprot.readStructBegin()
12848 
    while True:
12849 
      (fname, ftype, fid) = iprot.readFieldBegin()
12850 
      if ftype == TType.STOP:
12851 
        break
12852 
      else:
12853 
        iprot.skip(ftype)
12854 
      iprot.readFieldEnd()
12855 
    iprot.readStructEnd()
12856 
 
12857 
  def write(self, oprot):
12858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12860 
      return
12861 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12862 
    oprot.writeFieldStop()
12863 
    oprot.writeStructEnd()
12864 
 
3431 rajveer 12865 
  def validate(self):
12866 
    return
12867 
 
12868 
 
3064 chandransh 12869 
  def __repr__(self):
12870 
    L = ['%s=%r' % (key, value)
12871 
      for key, value in self.__dict__.iteritems()]
12872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12873 
 
12874 
  def __eq__(self, other):
12875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12876 
 
12877 
  def __ne__(self, other):
12878 
    return not (self == other)
12879 
 
12880 
class getValidOrdersAmountRange_result:
94 ashish 12881 
  """
12882 
  Attributes:
12883 
   - success
12884 
  """
12885 
 
12886 
  thrift_spec = (
3064 chandransh 12887 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12888 
  )
12889 
 
3064 chandransh 12890 
  def __init__(self, success=None,):
94 ashish 12891 
    self.success = success
12892 
 
12893 
  def read(self, iprot):
12894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12896 
      return
12897 
    iprot.readStructBegin()
12898 
    while True:
12899 
      (fname, ftype, fid) = iprot.readFieldBegin()
12900 
      if ftype == TType.STOP:
12901 
        break
12902 
      if fid == 0:
483 rajveer 12903 
        if ftype == TType.LIST:
12904 
          self.success = []
6188 rajveer 12905 
          (_etype249, _size246) = iprot.readListBegin()
12906 
          for _i250 in xrange(_size246):
12907 
            _elem251 = iprot.readDouble();
12908 
            self.success.append(_elem251)
483 rajveer 12909 
          iprot.readListEnd()
94 ashish 12910 
        else:
12911 
          iprot.skip(ftype)
12912 
      else:
12913 
        iprot.skip(ftype)
12914 
      iprot.readFieldEnd()
12915 
    iprot.readStructEnd()
12916 
 
12917 
  def write(self, oprot):
12918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12920 
      return
3064 chandransh 12921 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12922 
    if self.success is not None:
483 rajveer 12923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12924 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12925 
      for iter252 in self.success:
12926 
        oprot.writeDouble(iter252)
483 rajveer 12927 
      oprot.writeListEnd()
94 ashish 12928 
      oprot.writeFieldEnd()
12929 
    oprot.writeFieldStop()
12930 
    oprot.writeStructEnd()
12931 
 
3431 rajveer 12932 
  def validate(self):
12933 
    return
12934 
 
12935 
 
94 ashish 12936 
  def __repr__(self):
12937 
    L = ['%s=%r' % (key, value)
12938 
      for key, value in self.__dict__.iteritems()]
12939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12940 
 
12941 
  def __eq__(self, other):
12942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12943 
 
12944 
  def __ne__(self, other):
12945 
    return not (self == other)
12946 
 
3064 chandransh 12947 
class getValidOrders_args:
1528 ankur.sing 12948 
  """
12949 
  Attributes:
3064 chandransh 12950 
   - limit
5874 rajveer 12951 
   - onlyStore
1528 ankur.sing 12952 
  """
12953 
 
12954 
  thrift_spec = (
12955 
    None, # 0
3064 chandransh 12956 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12957 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12958 
  )
12959 
 
5874 rajveer 12960 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12961 
    self.limit = limit
5874 rajveer 12962 
    self.onlyStore = onlyStore
1528 ankur.sing 12963 
 
12964 
  def read(self, iprot):
12965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12967 
      return
12968 
    iprot.readStructBegin()
12969 
    while True:
12970 
      (fname, ftype, fid) = iprot.readFieldBegin()
12971 
      if ftype == TType.STOP:
12972 
        break
12973 
      if fid == 1:
12974 
        if ftype == TType.I64:
3064 chandransh 12975 
          self.limit = iprot.readI64();
1528 ankur.sing 12976 
        else:
12977 
          iprot.skip(ftype)
5874 rajveer 12978 
      elif fid == 2:
12979 
        if ftype == TType.BOOL:
12980 
          self.onlyStore = iprot.readBool();
12981 
        else:
12982 
          iprot.skip(ftype)
1528 ankur.sing 12983 
      else:
12984 
        iprot.skip(ftype)
12985 
      iprot.readFieldEnd()
12986 
    iprot.readStructEnd()
12987 
 
12988 
  def write(self, oprot):
12989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12991 
      return
3064 chandransh 12992 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12993 
    if self.limit is not None:
3064 chandransh 12994 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12995 
      oprot.writeI64(self.limit)
1528 ankur.sing 12996 
      oprot.writeFieldEnd()
5874 rajveer 12997 
    if self.onlyStore is not None:
12998 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12999 
      oprot.writeBool(self.onlyStore)
13000 
      oprot.writeFieldEnd()
1528 ankur.sing 13001 
    oprot.writeFieldStop()
13002 
    oprot.writeStructEnd()
13003 
 
3431 rajveer 13004 
  def validate(self):
13005 
    return
13006 
 
13007 
 
1528 ankur.sing 13008 
  def __repr__(self):
13009 
    L = ['%s=%r' % (key, value)
13010 
      for key, value in self.__dict__.iteritems()]
13011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13012 
 
13013 
  def __eq__(self, other):
13014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13015 
 
13016 
  def __ne__(self, other):
13017 
    return not (self == other)
13018 
 
3064 chandransh 13019 
class getValidOrders_result:
1528 ankur.sing 13020 
  """
13021 
  Attributes:
13022 
   - success
13023 
  """
13024 
 
13025 
  thrift_spec = (
3064 chandransh 13026 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13027 
  )
13028 
 
3064 chandransh 13029 
  def __init__(self, success=None,):
1528 ankur.sing 13030 
    self.success = success
13031 
 
13032 
  def read(self, iprot):
13033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13035 
      return
13036 
    iprot.readStructBegin()
13037 
    while True:
13038 
      (fname, ftype, fid) = iprot.readFieldBegin()
13039 
      if ftype == TType.STOP:
13040 
        break
13041 
      if fid == 0:
3064 chandransh 13042 
        if ftype == TType.LIST:
13043 
          self.success = []
6188 rajveer 13044 
          (_etype256, _size253) = iprot.readListBegin()
13045 
          for _i257 in xrange(_size253):
13046 
            _elem258 = Order()
13047 
            _elem258.read(iprot)
13048 
            self.success.append(_elem258)
3064 chandransh 13049 
          iprot.readListEnd()
1528 ankur.sing 13050 
        else:
13051 
          iprot.skip(ftype)
13052 
      else:
13053 
        iprot.skip(ftype)
13054 
      iprot.readFieldEnd()
13055 
    iprot.readStructEnd()
13056 
 
13057 
  def write(self, oprot):
13058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13060 
      return
3064 chandransh 13061 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13062 
    if self.success is not None:
3064 chandransh 13063 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13064 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13065 
      for iter259 in self.success:
13066 
        iter259.write(oprot)
3064 chandransh 13067 
      oprot.writeListEnd()
1528 ankur.sing 13068 
      oprot.writeFieldEnd()
13069 
    oprot.writeFieldStop()
13070 
    oprot.writeStructEnd()
13071 
 
3431 rajveer 13072 
  def validate(self):
13073 
    return
13074 
 
13075 
 
1528 ankur.sing 13076 
  def __repr__(self):
13077 
    L = ['%s=%r' % (key, value)
13078 
      for key, value in self.__dict__.iteritems()]
13079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13080 
 
13081 
  def __eq__(self, other):
13082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13083 
 
13084 
  def __ne__(self, other):
13085 
    return not (self == other)
13086 
 
1220 chandransh 13087 
class batchOrders_args:
13088 
  """
13089 
  Attributes:
13090 
   - warehouseId
13091 
  """
13092 
 
13093 
  thrift_spec = (
13094 
    None, # 0
13095 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13096 
  )
13097 
 
13098 
  def __init__(self, warehouseId=None,):
13099 
    self.warehouseId = warehouseId
13100 
 
13101 
  def read(self, iprot):
13102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13104 
      return
13105 
    iprot.readStructBegin()
13106 
    while True:
13107 
      (fname, ftype, fid) = iprot.readFieldBegin()
13108 
      if ftype == TType.STOP:
13109 
        break
13110 
      if fid == 1:
13111 
        if ftype == TType.I64:
13112 
          self.warehouseId = iprot.readI64();
13113 
        else:
13114 
          iprot.skip(ftype)
13115 
      else:
13116 
        iprot.skip(ftype)
13117 
      iprot.readFieldEnd()
13118 
    iprot.readStructEnd()
13119 
 
13120 
  def write(self, oprot):
13121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13123 
      return
13124 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13125 
    if self.warehouseId is not None:
1220 chandransh 13126 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13127 
      oprot.writeI64(self.warehouseId)
13128 
      oprot.writeFieldEnd()
13129 
    oprot.writeFieldStop()
13130 
    oprot.writeStructEnd()
13131 
 
3431 rajveer 13132 
  def validate(self):
13133 
    return
13134 
 
13135 
 
1220 chandransh 13136 
  def __repr__(self):
13137 
    L = ['%s=%r' % (key, value)
13138 
      for key, value in self.__dict__.iteritems()]
13139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13140 
 
13141 
  def __eq__(self, other):
13142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13143 
 
13144 
  def __ne__(self, other):
13145 
    return not (self == other)
13146 
 
13147 
class batchOrders_result:
13148 
  """
13149 
  Attributes:
13150 
   - success
13151 
   - ex
13152 
  """
13153 
 
13154 
  thrift_spec = (
13155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13156 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13157 
  )
13158 
 
13159 
  def __init__(self, success=None, ex=None,):
13160 
    self.success = success
13161 
    self.ex = ex
13162 
 
13163 
  def read(self, iprot):
13164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13166 
      return
13167 
    iprot.readStructBegin()
13168 
    while True:
13169 
      (fname, ftype, fid) = iprot.readFieldBegin()
13170 
      if ftype == TType.STOP:
13171 
        break
13172 
      if fid == 0:
13173 
        if ftype == TType.LIST:
13174 
          self.success = []
6188 rajveer 13175 
          (_etype263, _size260) = iprot.readListBegin()
13176 
          for _i264 in xrange(_size260):
13177 
            _elem265 = Order()
13178 
            _elem265.read(iprot)
13179 
            self.success.append(_elem265)
1220 chandransh 13180 
          iprot.readListEnd()
13181 
        else:
13182 
          iprot.skip(ftype)
13183 
      elif fid == 1:
13184 
        if ftype == TType.STRUCT:
13185 
          self.ex = TransactionServiceException()
13186 
          self.ex.read(iprot)
13187 
        else:
13188 
          iprot.skip(ftype)
13189 
      else:
13190 
        iprot.skip(ftype)
13191 
      iprot.readFieldEnd()
13192 
    iprot.readStructEnd()
13193 
 
13194 
  def write(self, oprot):
13195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13197 
      return
13198 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13199 
    if self.success is not None:
1220 chandransh 13200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13202 
      for iter266 in self.success:
13203 
        iter266.write(oprot)
1220 chandransh 13204 
      oprot.writeListEnd()
13205 
      oprot.writeFieldEnd()
3431 rajveer 13206 
    if self.ex is not None:
1220 chandransh 13207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13208 
      self.ex.write(oprot)
13209 
      oprot.writeFieldEnd()
13210 
    oprot.writeFieldStop()
13211 
    oprot.writeStructEnd()
13212 
 
3431 rajveer 13213 
  def validate(self):
13214 
    return
13215 
 
13216 
 
1220 chandransh 13217 
  def __repr__(self):
13218 
    L = ['%s=%r' % (key, value)
13219 
      for key, value in self.__dict__.iteritems()]
13220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13221 
 
13222 
  def __eq__(self, other):
13223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13224 
 
13225 
  def __ne__(self, other):
13226 
    return not (self == other)
13227 
 
1208 chandransh 13228 
class markOrderAsOutOfStock_args:
13229 
  """
13230 
  Attributes:
13231 
   - orderId
13232 
  """
13233 
 
13234 
  thrift_spec = (
13235 
    None, # 0
13236 
    (1, TType.I64, 'orderId', None, None, ), # 1
13237 
  )
13238 
 
13239 
  def __init__(self, orderId=None,):
13240 
    self.orderId = orderId
13241 
 
13242 
  def read(self, iprot):
13243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13245 
      return
13246 
    iprot.readStructBegin()
13247 
    while True:
13248 
      (fname, ftype, fid) = iprot.readFieldBegin()
13249 
      if ftype == TType.STOP:
13250 
        break
13251 
      if fid == 1:
13252 
        if ftype == TType.I64:
13253 
          self.orderId = iprot.readI64();
13254 
        else:
13255 
          iprot.skip(ftype)
13256 
      else:
13257 
        iprot.skip(ftype)
13258 
      iprot.readFieldEnd()
13259 
    iprot.readStructEnd()
13260 
 
13261 
  def write(self, oprot):
13262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13264 
      return
13265 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13266 
    if self.orderId is not None:
1208 chandransh 13267 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13268 
      oprot.writeI64(self.orderId)
13269 
      oprot.writeFieldEnd()
13270 
    oprot.writeFieldStop()
13271 
    oprot.writeStructEnd()
13272 
 
3431 rajveer 13273 
  def validate(self):
13274 
    return
13275 
 
13276 
 
1208 chandransh 13277 
  def __repr__(self):
13278 
    L = ['%s=%r' % (key, value)
13279 
      for key, value in self.__dict__.iteritems()]
13280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13281 
 
13282 
  def __eq__(self, other):
13283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13284 
 
13285 
  def __ne__(self, other):
13286 
    return not (self == other)
13287 
 
13288 
class markOrderAsOutOfStock_result:
13289 
  """
13290 
  Attributes:
13291 
   - success
13292 
   - ex
13293 
  """
13294 
 
13295 
  thrift_spec = (
13296 
    (0, TType.BOOL, 'success', None, None, ), # 0
13297 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13298 
  )
13299 
 
13300 
  def __init__(self, success=None, ex=None,):
13301 
    self.success = success
13302 
    self.ex = ex
13303 
 
13304 
  def read(self, iprot):
13305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13307 
      return
13308 
    iprot.readStructBegin()
13309 
    while True:
13310 
      (fname, ftype, fid) = iprot.readFieldBegin()
13311 
      if ftype == TType.STOP:
13312 
        break
13313 
      if fid == 0:
13314 
        if ftype == TType.BOOL:
13315 
          self.success = iprot.readBool();
13316 
        else:
13317 
          iprot.skip(ftype)
13318 
      elif fid == 1:
13319 
        if ftype == TType.STRUCT:
13320 
          self.ex = TransactionServiceException()
13321 
          self.ex.read(iprot)
13322 
        else:
13323 
          iprot.skip(ftype)
13324 
      else:
13325 
        iprot.skip(ftype)
13326 
      iprot.readFieldEnd()
13327 
    iprot.readStructEnd()
13328 
 
13329 
  def write(self, oprot):
13330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13332 
      return
13333 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13334 
    if self.success is not None:
1208 chandransh 13335 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13336 
      oprot.writeBool(self.success)
13337 
      oprot.writeFieldEnd()
3431 rajveer 13338 
    if self.ex is not None:
1208 chandransh 13339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13340 
      self.ex.write(oprot)
13341 
      oprot.writeFieldEnd()
13342 
    oprot.writeFieldStop()
13343 
    oprot.writeStructEnd()
13344 
 
3431 rajveer 13345 
  def validate(self):
13346 
    return
13347 
 
13348 
 
1208 chandransh 13349 
  def __repr__(self):
13350 
    L = ['%s=%r' % (key, value)
13351 
      for key, value in self.__dict__.iteritems()]
13352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13353 
 
13354 
  def __eq__(self, other):
13355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13356 
 
13357 
  def __ne__(self, other):
13358 
    return not (self == other)
13359 
 
3064 chandransh 13360 
class verifyOrder_args:
759 chandransh 13361 
  """
13362 
  Attributes:
3064 chandransh 13363 
   - orderId
759 chandransh 13364 
  """
13365 
 
13366 
  thrift_spec = (
13367 
    None, # 0
3064 chandransh 13368 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13369 
  )
13370 
 
3064 chandransh 13371 
  def __init__(self, orderId=None,):
13372 
    self.orderId = orderId
759 chandransh 13373 
 
13374 
  def read(self, iprot):
13375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13377 
      return
13378 
    iprot.readStructBegin()
13379 
    while True:
13380 
      (fname, ftype, fid) = iprot.readFieldBegin()
13381 
      if ftype == TType.STOP:
13382 
        break
13383 
      if fid == 1:
13384 
        if ftype == TType.I64:
3064 chandransh 13385 
          self.orderId = iprot.readI64();
759 chandransh 13386 
        else:
13387 
          iprot.skip(ftype)
13388 
      else:
13389 
        iprot.skip(ftype)
13390 
      iprot.readFieldEnd()
13391 
    iprot.readStructEnd()
13392 
 
13393 
  def write(self, oprot):
13394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13396 
      return
3064 chandransh 13397 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13398 
    if self.orderId is not None:
3064 chandransh 13399 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13400 
      oprot.writeI64(self.orderId)
759 chandransh 13401 
      oprot.writeFieldEnd()
13402 
    oprot.writeFieldStop()
13403 
    oprot.writeStructEnd()
13404 
 
3431 rajveer 13405 
  def validate(self):
13406 
    return
13407 
 
13408 
 
759 chandransh 13409 
  def __repr__(self):
13410 
    L = ['%s=%r' % (key, value)
13411 
      for key, value in self.__dict__.iteritems()]
13412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13413 
 
13414 
  def __eq__(self, other):
13415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13416 
 
13417 
  def __ne__(self, other):
13418 
    return not (self == other)
13419 
 
3064 chandransh 13420 
class verifyOrder_result:
759 chandransh 13421 
  """
13422 
  Attributes:
13423 
   - success
13424 
   - ex
13425 
  """
13426 
 
13427 
  thrift_spec = (
13428 
    (0, TType.BOOL, 'success', None, None, ), # 0
13429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13430 
  )
13431 
 
13432 
  def __init__(self, success=None, ex=None,):
13433 
    self.success = success
13434 
    self.ex = ex
13435 
 
13436 
  def read(self, iprot):
13437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13439 
      return
13440 
    iprot.readStructBegin()
13441 
    while True:
13442 
      (fname, ftype, fid) = iprot.readFieldBegin()
13443 
      if ftype == TType.STOP:
13444 
        break
13445 
      if fid == 0:
13446 
        if ftype == TType.BOOL:
13447 
          self.success = iprot.readBool();
13448 
        else:
13449 
          iprot.skip(ftype)
13450 
      elif fid == 1:
13451 
        if ftype == TType.STRUCT:
13452 
          self.ex = TransactionServiceException()
13453 
          self.ex.read(iprot)
13454 
        else:
13455 
          iprot.skip(ftype)
13456 
      else:
13457 
        iprot.skip(ftype)
13458 
      iprot.readFieldEnd()
13459 
    iprot.readStructEnd()
13460 
 
13461 
  def write(self, oprot):
13462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13464 
      return
3064 chandransh 13465 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13466 
    if self.success is not None:
759 chandransh 13467 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13468 
      oprot.writeBool(self.success)
13469 
      oprot.writeFieldEnd()
3431 rajveer 13470 
    if self.ex is not None:
759 chandransh 13471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13472 
      self.ex.write(oprot)
13473 
      oprot.writeFieldEnd()
13474 
    oprot.writeFieldStop()
13475 
    oprot.writeStructEnd()
13476 
 
3431 rajveer 13477 
  def validate(self):
13478 
    return
13479 
 
13480 
 
759 chandransh 13481 
  def __repr__(self):
13482 
    L = ['%s=%r' % (key, value)
13483 
      for key, value in self.__dict__.iteritems()]
13484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13485 
 
13486 
  def __eq__(self, other):
13487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13488 
 
13489 
  def __ne__(self, other):
13490 
    return not (self == other)
13491 
 
3064 chandransh 13492 
class acceptOrder_args:
1113 chandransh 13493 
  """
13494 
  Attributes:
3064 chandransh 13495 
   - orderId
1113 chandransh 13496 
  """
13497 
 
13498 
  thrift_spec = (
13499 
    None, # 0
3064 chandransh 13500 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13501 
  )
13502 
 
3064 chandransh 13503 
  def __init__(self, orderId=None,):
13504 
    self.orderId = orderId
1113 chandransh 13505 
 
13506 
  def read(self, iprot):
13507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13509 
      return
13510 
    iprot.readStructBegin()
13511 
    while True:
13512 
      (fname, ftype, fid) = iprot.readFieldBegin()
13513 
      if ftype == TType.STOP:
13514 
        break
13515 
      if fid == 1:
13516 
        if ftype == TType.I64:
3064 chandransh 13517 
          self.orderId = iprot.readI64();
1113 chandransh 13518 
        else:
13519 
          iprot.skip(ftype)
13520 
      else:
13521 
        iprot.skip(ftype)
13522 
      iprot.readFieldEnd()
13523 
    iprot.readStructEnd()
13524 
 
13525 
  def write(self, oprot):
13526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13528 
      return
3064 chandransh 13529 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13530 
    if self.orderId is not None:
3064 chandransh 13531 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13532 
      oprot.writeI64(self.orderId)
1113 chandransh 13533 
      oprot.writeFieldEnd()
13534 
    oprot.writeFieldStop()
13535 
    oprot.writeStructEnd()
13536 
 
3431 rajveer 13537 
  def validate(self):
13538 
    return
13539 
 
13540 
 
1113 chandransh 13541 
  def __repr__(self):
13542 
    L = ['%s=%r' % (key, value)
13543 
      for key, value in self.__dict__.iteritems()]
13544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13545 
 
13546 
  def __eq__(self, other):
13547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13548 
 
13549 
  def __ne__(self, other):
13550 
    return not (self == other)
13551 
 
3064 chandransh 13552 
class acceptOrder_result:
1113 chandransh 13553 
  """
13554 
  Attributes:
13555 
   - success
13556 
   - ex
13557 
  """
13558 
 
13559 
  thrift_spec = (
3064 chandransh 13560 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13562 
  )
13563 
 
13564 
  def __init__(self, success=None, ex=None,):
13565 
    self.success = success
13566 
    self.ex = ex
13567 
 
13568 
  def read(self, iprot):
13569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13571 
      return
13572 
    iprot.readStructBegin()
13573 
    while True:
13574 
      (fname, ftype, fid) = iprot.readFieldBegin()
13575 
      if ftype == TType.STOP:
13576 
        break
13577 
      if fid == 0:
3064 chandransh 13578 
        if ftype == TType.BOOL:
13579 
          self.success = iprot.readBool();
1113 chandransh 13580 
        else:
13581 
          iprot.skip(ftype)
13582 
      elif fid == 1:
13583 
        if ftype == TType.STRUCT:
13584 
          self.ex = TransactionServiceException()
13585 
          self.ex.read(iprot)
13586 
        else:
13587 
          iprot.skip(ftype)
13588 
      else:
13589 
        iprot.skip(ftype)
13590 
      iprot.readFieldEnd()
13591 
    iprot.readStructEnd()
13592 
 
13593 
  def write(self, oprot):
13594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13596 
      return
3064 chandransh 13597 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13598 
    if self.success is not None:
3064 chandransh 13599 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13600 
      oprot.writeBool(self.success)
1113 chandransh 13601 
      oprot.writeFieldEnd()
3431 rajveer 13602 
    if self.ex is not None:
1113 chandransh 13603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13604 
      self.ex.write(oprot)
13605 
      oprot.writeFieldEnd()
13606 
    oprot.writeFieldStop()
13607 
    oprot.writeStructEnd()
13608 
 
3431 rajveer 13609 
  def validate(self):
13610 
    return
13611 
 
13612 
 
1113 chandransh 13613 
  def __repr__(self):
13614 
    L = ['%s=%r' % (key, value)
13615 
      for key, value in self.__dict__.iteritems()]
13616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13617 
 
13618 
  def __eq__(self, other):
13619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13620 
 
13621 
  def __ne__(self, other):
13622 
    return not (self == other)
13623 
 
3064 chandransh 13624 
class addBillingDetails_args:
1135 chandransh 13625 
  """
13626 
  Attributes:
3064 chandransh 13627 
   - orderId
13628 
   - invoice_number
4658 mandeep.dh 13629 
   - serialNumber
4283 anupam.sin 13630 
   - itemNumber
3064 chandransh 13631 
   - billed_by
4264 rajveer 13632 
   - jacketNumber
4283 anupam.sin 13633 
   - billingType
5110 mandeep.dh 13634 
   - fulfilmentWarehouseId
4763 rajveer 13635 
   - authorize
1135 chandransh 13636 
  """
13637 
 
13638 
  thrift_spec = (
13639 
    None, # 0
3064 chandransh 13640 
    (1, TType.I64, 'orderId', None, None, ), # 1
13641 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13642 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13643 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13644 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13645 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13646 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13647 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13648 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13649 
  )
13650 
 
5110 mandeep.dh 13651 
  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 13652 
    self.orderId = orderId
13653 
    self.invoice_number = invoice_number
4658 mandeep.dh 13654 
    self.serialNumber = serialNumber
4283 anupam.sin 13655 
    self.itemNumber = itemNumber
3064 chandransh 13656 
    self.billed_by = billed_by
4264 rajveer 13657 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13658 
    self.billingType = billingType
5110 mandeep.dh 13659 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13660 
    self.authorize = authorize
1135 chandransh 13661 
 
13662 
  def read(self, iprot):
13663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13665 
      return
13666 
    iprot.readStructBegin()
13667 
    while True:
13668 
      (fname, ftype, fid) = iprot.readFieldBegin()
13669 
      if ftype == TType.STOP:
13670 
        break
13671 
      if fid == 1:
13672 
        if ftype == TType.I64:
3064 chandransh 13673 
          self.orderId = iprot.readI64();
1135 chandransh 13674 
        else:
13675 
          iprot.skip(ftype)
13676 
      elif fid == 2:
3064 chandransh 13677 
        if ftype == TType.STRING:
13678 
          self.invoice_number = iprot.readString();
1135 chandransh 13679 
        else:
13680 
          iprot.skip(ftype)
3064 chandransh 13681 
      elif fid == 3:
5411 rajveer 13682 
        if ftype == TType.LIST:
13683 
          self.serialNumber = []
6188 rajveer 13684 
          (_etype270, _size267) = iprot.readListBegin()
13685 
          for _i271 in xrange(_size267):
13686 
            _elem272 = iprot.readString();
13687 
            self.serialNumber.append(_elem272)
5411 rajveer 13688 
          iprot.readListEnd()
3064 chandransh 13689 
        else:
13690 
          iprot.skip(ftype)
13691 
      elif fid == 4:
5411 rajveer 13692 
        if ftype == TType.LIST:
13693 
          self.itemNumber = []
6188 rajveer 13694 
          (_etype276, _size273) = iprot.readListBegin()
13695 
          for _i277 in xrange(_size273):
13696 
            _elem278 = iprot.readString();
13697 
            self.itemNumber.append(_elem278)
5411 rajveer 13698 
          iprot.readListEnd()
3064 chandransh 13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      elif fid == 5:
13702 
        if ftype == TType.STRING:
4283 anupam.sin 13703 
          self.billed_by = iprot.readString();
3064 chandransh 13704 
        else:
13705 
          iprot.skip(ftype)
13706 
      elif fid == 6:
13707 
        if ftype == TType.I64:
4283 anupam.sin 13708 
          self.jacketNumber = iprot.readI64();
13709 
        else:
13710 
          iprot.skip(ftype)
13711 
      elif fid == 7:
13712 
        if ftype == TType.I64:
3064 chandransh 13713 
          self.billingType = iprot.readI64();
13714 
        else:
13715 
          iprot.skip(ftype)
4283 anupam.sin 13716 
      elif fid == 8:
13717 
        if ftype == TType.I64:
5110 mandeep.dh 13718 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13719 
        else:
13720 
          iprot.skip(ftype)
4763 rajveer 13721 
      elif fid == 9:
13722 
        if ftype == TType.BOOL:
13723 
          self.authorize = iprot.readBool();
13724 
        else:
13725 
          iprot.skip(ftype)
1246 chandransh 13726 
      else:
13727 
        iprot.skip(ftype)
13728 
      iprot.readFieldEnd()
13729 
    iprot.readStructEnd()
13730 
 
13731 
  def write(self, oprot):
13732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13734 
      return
4283 anupam.sin 13735 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13736 
    if self.orderId is not None:
3064 chandransh 13737 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13738 
      oprot.writeI64(self.orderId)
1246 chandransh 13739 
      oprot.writeFieldEnd()
4283 anupam.sin 13740 
    if self.invoice_number is not None:
13741 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13742 
      oprot.writeString(self.invoice_number)
1246 chandransh 13743 
      oprot.writeFieldEnd()
4658 mandeep.dh 13744 
    if self.serialNumber is not None:
5411 rajveer 13745 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13746 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13747 
      for iter279 in self.serialNumber:
13748 
        oprot.writeString(iter279)
5411 rajveer 13749 
      oprot.writeListEnd()
3064 chandransh 13750 
      oprot.writeFieldEnd()
3431 rajveer 13751 
    if self.itemNumber is not None:
5411 rajveer 13752 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13753 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13754 
      for iter280 in self.itemNumber:
13755 
        oprot.writeString(iter280)
5411 rajveer 13756 
      oprot.writeListEnd()
3064 chandransh 13757 
      oprot.writeFieldEnd()
4283 anupam.sin 13758 
    if self.billed_by is not None:
13759 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13760 
      oprot.writeString(self.billed_by)
3064 chandransh 13761 
      oprot.writeFieldEnd()
4283 anupam.sin 13762 
    if self.jacketNumber is not None:
13763 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13764 
      oprot.writeI64(self.jacketNumber)
13765 
      oprot.writeFieldEnd()
3431 rajveer 13766 
    if self.billingType is not None:
4283 anupam.sin 13767 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13768 
      oprot.writeI64(self.billingType)
13769 
      oprot.writeFieldEnd()
5110 mandeep.dh 13770 
    if self.fulfilmentWarehouseId is not None:
13771 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13772 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13773 
      oprot.writeFieldEnd()
4763 rajveer 13774 
    if self.authorize is not None:
13775 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13776 
      oprot.writeBool(self.authorize)
13777 
      oprot.writeFieldEnd()
1246 chandransh 13778 
    oprot.writeFieldStop()
13779 
    oprot.writeStructEnd()
13780 
 
3431 rajveer 13781 
  def validate(self):
13782 
    return
13783 
 
13784 
 
1246 chandransh 13785 
  def __repr__(self):
13786 
    L = ['%s=%r' % (key, value)
13787 
      for key, value in self.__dict__.iteritems()]
13788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13789 
 
13790 
  def __eq__(self, other):
13791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13792 
 
13793 
  def __ne__(self, other):
13794 
    return not (self == other)
13795 
 
4283 anupam.sin 13796 
class addBillingDetails_result:
1246 chandransh 13797 
  """
13798 
  Attributes:
3064 chandransh 13799 
   - success
1246 chandransh 13800 
   - ex
13801 
  """
13802 
 
13803 
  thrift_spec = (
3064 chandransh 13804 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13805 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13806 
  )
13807 
 
3064 chandransh 13808 
  def __init__(self, success=None, ex=None,):
13809 
    self.success = success
1246 chandransh 13810 
    self.ex = ex
13811 
 
13812 
  def read(self, iprot):
13813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13815 
      return
13816 
    iprot.readStructBegin()
13817 
    while True:
13818 
      (fname, ftype, fid) = iprot.readFieldBegin()
13819 
      if ftype == TType.STOP:
13820 
        break
3064 chandransh 13821 
      if fid == 0:
13822 
        if ftype == TType.BOOL:
13823 
          self.success = iprot.readBool();
13824 
        else:
13825 
          iprot.skip(ftype)
13826 
      elif fid == 1:
1246 chandransh 13827 
        if ftype == TType.STRUCT:
13828 
          self.ex = TransactionServiceException()
13829 
          self.ex.read(iprot)
13830 
        else:
13831 
          iprot.skip(ftype)
13832 
      else:
13833 
        iprot.skip(ftype)
13834 
      iprot.readFieldEnd()
13835 
    iprot.readStructEnd()
13836 
 
13837 
  def write(self, oprot):
13838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13840 
      return
4283 anupam.sin 13841 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13842 
    if self.success is not None:
3064 chandransh 13843 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13844 
      oprot.writeBool(self.success)
13845 
      oprot.writeFieldEnd()
3431 rajveer 13846 
    if self.ex is not None:
1246 chandransh 13847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13848 
      self.ex.write(oprot)
13849 
      oprot.writeFieldEnd()
13850 
    oprot.writeFieldStop()
13851 
    oprot.writeStructEnd()
13852 
 
3431 rajveer 13853 
  def validate(self):
13854 
    return
13855 
 
13856 
 
1246 chandransh 13857 
  def __repr__(self):
13858 
    L = ['%s=%r' % (key, value)
13859 
      for key, value in self.__dict__.iteritems()]
13860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13861 
 
13862 
  def __eq__(self, other):
13863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13864 
 
13865 
  def __ne__(self, other):
13866 
    return not (self == other)
13867 
 
4579 rajveer 13868 
class addInvoiceNumber_args:
13869 
  """
13870 
  Attributes:
13871 
   - orderId
13872 
   - invoiceNumber
4763 rajveer 13873 
   - color
6756 amar.kumar 13874 
   - serialNumber
13875 
   - itemNumber
4579 rajveer 13876 
  """
13877 
 
13878 
  thrift_spec = (
13879 
    None, # 0
13880 
    (1, TType.I64, 'orderId', None, None, ), # 1
13881 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13882 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 13883 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
13884 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 13885 
  )
13886 
 
6756 amar.kumar 13887 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 13888 
    self.orderId = orderId
13889 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13890 
    self.color = color
6756 amar.kumar 13891 
    self.serialNumber = serialNumber
13892 
    self.itemNumber = itemNumber
4579 rajveer 13893 
 
13894 
  def read(self, iprot):
13895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13897 
      return
13898 
    iprot.readStructBegin()
13899 
    while True:
13900 
      (fname, ftype, fid) = iprot.readFieldBegin()
13901 
      if ftype == TType.STOP:
13902 
        break
13903 
      if fid == 1:
13904 
        if ftype == TType.I64:
13905 
          self.orderId = iprot.readI64();
13906 
        else:
13907 
          iprot.skip(ftype)
13908 
      elif fid == 2:
13909 
        if ftype == TType.STRING:
13910 
          self.invoiceNumber = iprot.readString();
13911 
        else:
13912 
          iprot.skip(ftype)
4763 rajveer 13913 
      elif fid == 3:
13914 
        if ftype == TType.STRING:
13915 
          self.color = iprot.readString();
13916 
        else:
13917 
          iprot.skip(ftype)
6756 amar.kumar 13918 
      elif fid == 4:
13919 
        if ftype == TType.STRING:
13920 
          self.serialNumber = iprot.readString();
13921 
        else:
13922 
          iprot.skip(ftype)
13923 
      elif fid == 5:
13924 
        if ftype == TType.STRING:
13925 
          self.itemNumber = iprot.readString();
13926 
        else:
13927 
          iprot.skip(ftype)
4579 rajveer 13928 
      else:
13929 
        iprot.skip(ftype)
13930 
      iprot.readFieldEnd()
13931 
    iprot.readStructEnd()
13932 
 
13933 
  def write(self, oprot):
13934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13936 
      return
13937 
    oprot.writeStructBegin('addInvoiceNumber_args')
13938 
    if self.orderId is not None:
13939 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13940 
      oprot.writeI64(self.orderId)
13941 
      oprot.writeFieldEnd()
13942 
    if self.invoiceNumber is not None:
13943 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13944 
      oprot.writeString(self.invoiceNumber)
13945 
      oprot.writeFieldEnd()
4763 rajveer 13946 
    if self.color is not None:
13947 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13948 
      oprot.writeString(self.color)
13949 
      oprot.writeFieldEnd()
6756 amar.kumar 13950 
    if self.serialNumber is not None:
13951 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
13952 
      oprot.writeString(self.serialNumber)
13953 
      oprot.writeFieldEnd()
13954 
    if self.itemNumber is not None:
13955 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
13956 
      oprot.writeString(self.itemNumber)
13957 
      oprot.writeFieldEnd()
4579 rajveer 13958 
    oprot.writeFieldStop()
13959 
    oprot.writeStructEnd()
13960 
 
13961 
  def validate(self):
13962 
    return
13963 
 
13964 
 
13965 
  def __repr__(self):
13966 
    L = ['%s=%r' % (key, value)
13967 
      for key, value in self.__dict__.iteritems()]
13968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13969 
 
13970 
  def __eq__(self, other):
13971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13972 
 
13973 
  def __ne__(self, other):
13974 
    return not (self == other)
13975 
 
13976 
class addInvoiceNumber_result:
13977 
  """
13978 
  Attributes:
13979 
   - ex
13980 
  """
13981 
 
13982 
  thrift_spec = (
13983 
    None, # 0
13984 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13985 
  )
13986 
 
13987 
  def __init__(self, ex=None,):
13988 
    self.ex = ex
13989 
 
13990 
  def read(self, iprot):
13991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13993 
      return
13994 
    iprot.readStructBegin()
13995 
    while True:
13996 
      (fname, ftype, fid) = iprot.readFieldBegin()
13997 
      if ftype == TType.STOP:
13998 
        break
13999 
      if fid == 1:
14000 
        if ftype == TType.STRUCT:
14001 
          self.ex = TransactionServiceException()
14002 
          self.ex.read(iprot)
14003 
        else:
14004 
          iprot.skip(ftype)
14005 
      else:
14006 
        iprot.skip(ftype)
14007 
      iprot.readFieldEnd()
14008 
    iprot.readStructEnd()
14009 
 
14010 
  def write(self, oprot):
14011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14013 
      return
14014 
    oprot.writeStructBegin('addInvoiceNumber_result')
14015 
    if self.ex is not None:
14016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14017 
      self.ex.write(oprot)
14018 
      oprot.writeFieldEnd()
14019 
    oprot.writeFieldStop()
14020 
    oprot.writeStructEnd()
14021 
 
14022 
  def validate(self):
14023 
    return
14024 
 
14025 
 
14026 
  def __repr__(self):
14027 
    L = ['%s=%r' % (key, value)
14028 
      for key, value in self.__dict__.iteritems()]
14029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14030 
 
14031 
  def __eq__(self, other):
14032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14033 
 
14034 
  def __ne__(self, other):
14035 
    return not (self == other)
14036 
 
4910 phani.kuma 14037 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14038 
  """
14039 
  Attributes:
3064 chandransh 14040 
   - warehouseId
1408 ankur.sing 14041 
   - providerId
3064 chandransh 14042 
   - cod
4910 phani.kuma 14043 
   - orderIds
1408 ankur.sing 14044 
  """
14045 
 
14046 
  thrift_spec = (
14047 
    None, # 0
3064 chandransh 14048 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14049 
    (2, TType.I64, 'providerId', None, None, ), # 2
14050 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14051 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14052 
  )
14053 
 
4910 phani.kuma 14054 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14055 
    self.warehouseId = warehouseId
1408 ankur.sing 14056 
    self.providerId = providerId
3064 chandransh 14057 
    self.cod = cod
4910 phani.kuma 14058 
    self.orderIds = orderIds
1408 ankur.sing 14059 
 
14060 
  def read(self, iprot):
14061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14063 
      return
14064 
    iprot.readStructBegin()
14065 
    while True:
14066 
      (fname, ftype, fid) = iprot.readFieldBegin()
14067 
      if ftype == TType.STOP:
14068 
        break
14069 
      if fid == 1:
14070 
        if ftype == TType.I64:
3064 chandransh 14071 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14072 
        else:
14073 
          iprot.skip(ftype)
14074 
      elif fid == 2:
14075 
        if ftype == TType.I64:
3064 chandransh 14076 
          self.providerId = iprot.readI64();
1408 ankur.sing 14077 
        else:
14078 
          iprot.skip(ftype)
3064 chandransh 14079 
      elif fid == 3:
14080 
        if ftype == TType.BOOL:
14081 
          self.cod = iprot.readBool();
14082 
        else:
14083 
          iprot.skip(ftype)
4910 phani.kuma 14084 
      elif fid == 4:
14085 
        if ftype == TType.LIST:
14086 
          self.orderIds = []
6188 rajveer 14087 
          (_etype284, _size281) = iprot.readListBegin()
14088 
          for _i285 in xrange(_size281):
14089 
            _elem286 = iprot.readI64();
14090 
            self.orderIds.append(_elem286)
4910 phani.kuma 14091 
          iprot.readListEnd()
14092 
        else:
14093 
          iprot.skip(ftype)
1408 ankur.sing 14094 
      else:
14095 
        iprot.skip(ftype)
14096 
      iprot.readFieldEnd()
14097 
    iprot.readStructEnd()
14098 
 
14099 
  def write(self, oprot):
14100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14102 
      return
4910 phani.kuma 14103 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14104 
    if self.warehouseId is not None:
3064 chandransh 14105 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14106 
      oprot.writeI64(self.warehouseId)
14107 
      oprot.writeFieldEnd()
3431 rajveer 14108 
    if self.providerId is not None:
3064 chandransh 14109 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14110 
      oprot.writeI64(self.providerId)
14111 
      oprot.writeFieldEnd()
3431 rajveer 14112 
    if self.cod is not None:
3064 chandransh 14113 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14114 
      oprot.writeBool(self.cod)
1408 ankur.sing 14115 
      oprot.writeFieldEnd()
4910 phani.kuma 14116 
    if self.orderIds is not None:
14117 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14118 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14119 
      for iter287 in self.orderIds:
14120 
        oprot.writeI64(iter287)
4910 phani.kuma 14121 
      oprot.writeListEnd()
14122 
      oprot.writeFieldEnd()
1408 ankur.sing 14123 
    oprot.writeFieldStop()
14124 
    oprot.writeStructEnd()
14125 
 
3431 rajveer 14126 
  def validate(self):
14127 
    return
14128 
 
14129 
 
1408 ankur.sing 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 
 
4910 phani.kuma 14141 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14142 
  """
14143 
  Attributes:
14144 
   - success
3064 chandransh 14145 
   - ex
1408 ankur.sing 14146 
  """
14147 
 
14148 
  thrift_spec = (
3064 chandransh 14149 
    (0, TType.BOOL, 'success', None, None, ), # 0
14150 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14151 
  )
14152 
 
3064 chandransh 14153 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14154 
    self.success = success
3064 chandransh 14155 
    self.ex = ex
1408 ankur.sing 14156 
 
14157 
  def read(self, iprot):
14158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14160 
      return
14161 
    iprot.readStructBegin()
14162 
    while True:
14163 
      (fname, ftype, fid) = iprot.readFieldBegin()
14164 
      if ftype == TType.STOP:
14165 
        break
14166 
      if fid == 0:
3064 chandransh 14167 
        if ftype == TType.BOOL:
14168 
          self.success = iprot.readBool();
1408 ankur.sing 14169 
        else:
14170 
          iprot.skip(ftype)
3064 chandransh 14171 
      elif fid == 1:
14172 
        if ftype == TType.STRUCT:
14173 
          self.ex = TransactionServiceException()
14174 
          self.ex.read(iprot)
14175 
        else:
14176 
          iprot.skip(ftype)
1408 ankur.sing 14177 
      else:
14178 
        iprot.skip(ftype)
14179 
      iprot.readFieldEnd()
14180 
    iprot.readStructEnd()
14181 
 
14182 
  def write(self, oprot):
14183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14185 
      return
4910 phani.kuma 14186 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14187 
    if self.success is not None:
3064 chandransh 14188 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14189 
      oprot.writeBool(self.success)
1408 ankur.sing 14190 
      oprot.writeFieldEnd()
3431 rajveer 14191 
    if self.ex is not None:
3064 chandransh 14192 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14193 
      self.ex.write(oprot)
14194 
      oprot.writeFieldEnd()
1408 ankur.sing 14195 
    oprot.writeFieldStop()
14196 
    oprot.writeStructEnd()
14197 
 
3431 rajveer 14198 
  def validate(self):
14199 
    return
14200 
 
14201 
 
1408 ankur.sing 14202 
  def __repr__(self):
14203 
    L = ['%s=%r' % (key, value)
14204 
      for key, value in self.__dict__.iteritems()]
14205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14206 
 
14207 
  def __eq__(self, other):
14208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14209 
 
14210 
  def __ne__(self, other):
14211 
    return not (self == other)
14212 
 
5676 rajveer 14213 
class markOrdersAsReturnedFromStore_args:
14214 
  """
14215 
  Attributes:
14216 
   - providerId
14217 
   - orderIds
5713 rajveer 14218 
   - awbs
5676 rajveer 14219 
  """
14220 
 
14221 
  thrift_spec = (
14222 
    None, # 0
14223 
    (1, TType.I64, 'providerId', None, None, ), # 1
14224 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14225 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14226 
  )
14227 
 
5713 rajveer 14228 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14229 
    self.providerId = providerId
14230 
    self.orderIds = orderIds
5713 rajveer 14231 
    self.awbs = awbs
5676 rajveer 14232 
 
14233 
  def read(self, iprot):
14234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14236 
      return
14237 
    iprot.readStructBegin()
14238 
    while True:
14239 
      (fname, ftype, fid) = iprot.readFieldBegin()
14240 
      if ftype == TType.STOP:
14241 
        break
14242 
      if fid == 1:
14243 
        if ftype == TType.I64:
14244 
          self.providerId = iprot.readI64();
14245 
        else:
14246 
          iprot.skip(ftype)
14247 
      elif fid == 2:
14248 
        if ftype == TType.LIST:
14249 
          self.orderIds = []
6188 rajveer 14250 
          (_etype291, _size288) = iprot.readListBegin()
14251 
          for _i292 in xrange(_size288):
14252 
            _elem293 = iprot.readI64();
14253 
            self.orderIds.append(_elem293)
5676 rajveer 14254 
          iprot.readListEnd()
14255 
        else:
14256 
          iprot.skip(ftype)
5713 rajveer 14257 
      elif fid == 3:
14258 
        if ftype == TType.LIST:
14259 
          self.awbs = []
6188 rajveer 14260 
          (_etype297, _size294) = iprot.readListBegin()
14261 
          for _i298 in xrange(_size294):
14262 
            _elem299 = iprot.readString();
14263 
            self.awbs.append(_elem299)
5713 rajveer 14264 
          iprot.readListEnd()
14265 
        else:
14266 
          iprot.skip(ftype)
5676 rajveer 14267 
      else:
14268 
        iprot.skip(ftype)
14269 
      iprot.readFieldEnd()
14270 
    iprot.readStructEnd()
14271 
 
14272 
  def write(self, oprot):
14273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14275 
      return
14276 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14277 
    if self.providerId is not None:
14278 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14279 
      oprot.writeI64(self.providerId)
14280 
      oprot.writeFieldEnd()
14281 
    if self.orderIds is not None:
14282 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14283 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14284 
      for iter300 in self.orderIds:
14285 
        oprot.writeI64(iter300)
5676 rajveer 14286 
      oprot.writeListEnd()
14287 
      oprot.writeFieldEnd()
5713 rajveer 14288 
    if self.awbs is not None:
14289 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14290 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14291 
      for iter301 in self.awbs:
14292 
        oprot.writeString(iter301)
5713 rajveer 14293 
      oprot.writeListEnd()
14294 
      oprot.writeFieldEnd()
5676 rajveer 14295 
    oprot.writeFieldStop()
14296 
    oprot.writeStructEnd()
14297 
 
14298 
  def validate(self):
14299 
    return
14300 
 
14301 
 
14302 
  def __repr__(self):
14303 
    L = ['%s=%r' % (key, value)
14304 
      for key, value in self.__dict__.iteritems()]
14305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14306 
 
14307 
  def __eq__(self, other):
14308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14309 
 
14310 
  def __ne__(self, other):
14311 
    return not (self == other)
14312 
 
14313 
class markOrdersAsReturnedFromStore_result:
14314 
  """
14315 
  Attributes:
14316 
   - success
14317 
   - ex
14318 
  """
14319 
 
14320 
  thrift_spec = (
14321 
    (0, TType.BOOL, 'success', None, None, ), # 0
14322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14323 
  )
14324 
 
14325 
  def __init__(self, success=None, ex=None,):
14326 
    self.success = success
14327 
    self.ex = ex
14328 
 
14329 
  def read(self, iprot):
14330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14332 
      return
14333 
    iprot.readStructBegin()
14334 
    while True:
14335 
      (fname, ftype, fid) = iprot.readFieldBegin()
14336 
      if ftype == TType.STOP:
14337 
        break
14338 
      if fid == 0:
14339 
        if ftype == TType.BOOL:
14340 
          self.success = iprot.readBool();
14341 
        else:
14342 
          iprot.skip(ftype)
14343 
      elif fid == 1:
14344 
        if ftype == TType.STRUCT:
14345 
          self.ex = TransactionServiceException()
14346 
          self.ex.read(iprot)
14347 
        else:
14348 
          iprot.skip(ftype)
14349 
      else:
14350 
        iprot.skip(ftype)
14351 
      iprot.readFieldEnd()
14352 
    iprot.readStructEnd()
14353 
 
14354 
  def write(self, oprot):
14355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14357 
      return
14358 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14359 
    if self.success is not None:
14360 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14361 
      oprot.writeBool(self.success)
14362 
      oprot.writeFieldEnd()
14363 
    if self.ex is not None:
14364 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14365 
      self.ex.write(oprot)
14366 
      oprot.writeFieldEnd()
14367 
    oprot.writeFieldStop()
14368 
    oprot.writeStructEnd()
14369 
 
14370 
  def validate(self):
14371 
    return
14372 
 
14373 
 
14374 
  def __repr__(self):
14375 
    L = ['%s=%r' % (key, value)
14376 
      for key, value in self.__dict__.iteritems()]
14377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14378 
 
14379 
  def __eq__(self, other):
14380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14381 
 
14382 
  def __ne__(self, other):
14383 
    return not (self == other)
14384 
 
4910 phani.kuma 14385 
class markOrdersAsPickedUp_args:
4410 rajveer 14386 
  """
14387 
  Attributes:
14388 
   - providerId
4910 phani.kuma 14389 
   - pickupDetails
4410 rajveer 14390 
  """
14391 
 
14392 
  thrift_spec = (
14393 
    None, # 0
4910 phani.kuma 14394 
    (1, TType.I64, 'providerId', None, None, ), # 1
14395 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14396 
  )
14397 
 
4910 phani.kuma 14398 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14399 
    self.providerId = providerId
4910 phani.kuma 14400 
    self.pickupDetails = pickupDetails
4410 rajveer 14401 
 
14402 
  def read(self, iprot):
14403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14405 
      return
14406 
    iprot.readStructBegin()
14407 
    while True:
14408 
      (fname, ftype, fid) = iprot.readFieldBegin()
14409 
      if ftype == TType.STOP:
14410 
        break
14411 
      if fid == 1:
14412 
        if ftype == TType.I64:
4910 phani.kuma 14413 
          self.providerId = iprot.readI64();
4410 rajveer 14414 
        else:
14415 
          iprot.skip(ftype)
14416 
      elif fid == 2:
4910 phani.kuma 14417 
        if ftype == TType.MAP:
14418 
          self.pickupDetails = {}
6188 rajveer 14419 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14420 
          for _i306 in xrange(_size302):
14421 
            _key307 = iprot.readString();
14422 
            _val308 = iprot.readString();
14423 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14424 
          iprot.readMapEnd()
4410 rajveer 14425 
        else:
14426 
          iprot.skip(ftype)
14427 
      else:
14428 
        iprot.skip(ftype)
14429 
      iprot.readFieldEnd()
14430 
    iprot.readStructEnd()
14431 
 
14432 
  def write(self, oprot):
14433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14435 
      return
4910 phani.kuma 14436 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14437 
    if self.providerId is not None:
4910 phani.kuma 14438 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14439 
      oprot.writeI64(self.providerId)
14440 
      oprot.writeFieldEnd()
4910 phani.kuma 14441 
    if self.pickupDetails is not None:
14442 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14443 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14444 
      for kiter309,viter310 in self.pickupDetails.items():
14445 
        oprot.writeString(kiter309)
14446 
        oprot.writeString(viter310)
4910 phani.kuma 14447 
      oprot.writeMapEnd()
4410 rajveer 14448 
      oprot.writeFieldEnd()
14449 
    oprot.writeFieldStop()
14450 
    oprot.writeStructEnd()
14451 
 
14452 
  def validate(self):
14453 
    return
14454 
 
14455 
 
14456 
  def __repr__(self):
14457 
    L = ['%s=%r' % (key, value)
14458 
      for key, value in self.__dict__.iteritems()]
14459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14460 
 
14461 
  def __eq__(self, other):
14462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14463 
 
14464 
  def __ne__(self, other):
14465 
    return not (self == other)
14466 
 
4910 phani.kuma 14467 
class markOrdersAsPickedUp_result:
4410 rajveer 14468 
  """
14469 
  Attributes:
14470 
   - ex
14471 
  """
14472 
 
14473 
  thrift_spec = (
4910 phani.kuma 14474 
    None, # 0
4410 rajveer 14475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14476 
  )
14477 
 
4910 phani.kuma 14478 
  def __init__(self, ex=None,):
4410 rajveer 14479 
    self.ex = ex
14480 
 
14481 
  def read(self, iprot):
14482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14484 
      return
14485 
    iprot.readStructBegin()
14486 
    while True:
14487 
      (fname, ftype, fid) = iprot.readFieldBegin()
14488 
      if ftype == TType.STOP:
14489 
        break
4910 phani.kuma 14490 
      if fid == 1:
4410 rajveer 14491 
        if ftype == TType.STRUCT:
14492 
          self.ex = TransactionServiceException()
14493 
          self.ex.read(iprot)
14494 
        else:
14495 
          iprot.skip(ftype)
14496 
      else:
14497 
        iprot.skip(ftype)
14498 
      iprot.readFieldEnd()
14499 
    iprot.readStructEnd()
14500 
 
14501 
  def write(self, oprot):
14502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14504 
      return
4910 phani.kuma 14505 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14506 
    if self.ex is not None:
14507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14508 
      self.ex.write(oprot)
14509 
      oprot.writeFieldEnd()
14510 
    oprot.writeFieldStop()
14511 
    oprot.writeStructEnd()
14512 
 
14513 
  def validate(self):
14514 
    return
14515 
 
14516 
 
14517 
  def __repr__(self):
14518 
    L = ['%s=%r' % (key, value)
14519 
      for key, value in self.__dict__.iteritems()]
14520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14521 
 
14522 
  def __eq__(self, other):
14523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14524 
 
14525 
  def __ne__(self, other):
14526 
    return not (self == other)
14527 
 
4910 phani.kuma 14528 
class getOrdersNotPickedUp_args:
304 ashish 14529 
  """
14530 
  Attributes:
3064 chandransh 14531 
   - providerId
304 ashish 14532 
  """
94 ashish 14533 
 
304 ashish 14534 
  thrift_spec = (
14535 
    None, # 0
3064 chandransh 14536 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14537 
  )
14538 
 
4910 phani.kuma 14539 
  def __init__(self, providerId=None,):
3064 chandransh 14540 
    self.providerId = providerId
304 ashish 14541 
 
14542 
  def read(self, iprot):
14543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14545 
      return
14546 
    iprot.readStructBegin()
14547 
    while True:
14548 
      (fname, ftype, fid) = iprot.readFieldBegin()
14549 
      if ftype == TType.STOP:
14550 
        break
14551 
      if fid == 1:
14552 
        if ftype == TType.I64:
3064 chandransh 14553 
          self.providerId = iprot.readI64();
304 ashish 14554 
        else:
14555 
          iprot.skip(ftype)
14556 
      else:
14557 
        iprot.skip(ftype)
14558 
      iprot.readFieldEnd()
14559 
    iprot.readStructEnd()
14560 
 
14561 
  def write(self, oprot):
14562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14564 
      return
4910 phani.kuma 14565 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14566 
    if self.providerId is not None:
3064 chandransh 14567 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14568 
      oprot.writeI64(self.providerId)
304 ashish 14569 
      oprot.writeFieldEnd()
14570 
    oprot.writeFieldStop()
14571 
    oprot.writeStructEnd()
14572 
 
3431 rajveer 14573 
  def validate(self):
14574 
    return
14575 
 
14576 
 
304 ashish 14577 
  def __repr__(self):
14578 
    L = ['%s=%r' % (key, value)
14579 
      for key, value in self.__dict__.iteritems()]
14580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14581 
 
14582 
  def __eq__(self, other):
14583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14584 
 
14585 
  def __ne__(self, other):
14586 
    return not (self == other)
14587 
 
4910 phani.kuma 14588 
class getOrdersNotPickedUp_result:
304 ashish 14589 
  """
14590 
  Attributes:
14591 
   - success
14592 
  """
14593 
 
14594 
  thrift_spec = (
3064 chandransh 14595 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14596 
  )
14597 
 
4910 phani.kuma 14598 
  def __init__(self, success=None,):
304 ashish 14599 
    self.success = success
14600 
 
14601 
  def read(self, iprot):
14602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14604 
      return
14605 
    iprot.readStructBegin()
14606 
    while True:
14607 
      (fname, ftype, fid) = iprot.readFieldBegin()
14608 
      if ftype == TType.STOP:
14609 
        break
14610 
      if fid == 0:
14611 
        if ftype == TType.LIST:
14612 
          self.success = []
6188 rajveer 14613 
          (_etype314, _size311) = iprot.readListBegin()
14614 
          for _i315 in xrange(_size311):
14615 
            _elem316 = Order()
14616 
            _elem316.read(iprot)
14617 
            self.success.append(_elem316)
304 ashish 14618 
          iprot.readListEnd()
14619 
        else:
14620 
          iprot.skip(ftype)
14621 
      else:
14622 
        iprot.skip(ftype)
14623 
      iprot.readFieldEnd()
14624 
    iprot.readStructEnd()
14625 
 
14626 
  def write(self, oprot):
14627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14629 
      return
4910 phani.kuma 14630 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14631 
    if self.success is not None:
304 ashish 14632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14634 
      for iter317 in self.success:
14635 
        iter317.write(oprot)
304 ashish 14636 
      oprot.writeListEnd()
14637 
      oprot.writeFieldEnd()
14638 
    oprot.writeFieldStop()
14639 
    oprot.writeStructEnd()
14640 
 
3431 rajveer 14641 
  def validate(self):
14642 
    return
14643 
 
14644 
 
304 ashish 14645 
  def __repr__(self):
14646 
    L = ['%s=%r' % (key, value)
14647 
      for key, value in self.__dict__.iteritems()]
14648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14649 
 
14650 
  def __eq__(self, other):
14651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14652 
 
14653 
  def __ne__(self, other):
14654 
    return not (self == other)
14655 
 
3064 chandransh 14656 
class markOrdersAsDelivered_args:
304 ashish 14657 
  """
14658 
  Attributes:
3064 chandransh 14659 
   - providerId
14660 
   - deliveredOrders
304 ashish 14661 
  """
14662 
 
14663 
  thrift_spec = (
14664 
    None, # 0
3064 chandransh 14665 
    (1, TType.I64, 'providerId', None, None, ), # 1
14666 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14667 
  )
14668 
 
3064 chandransh 14669 
  def __init__(self, providerId=None, deliveredOrders=None,):
14670 
    self.providerId = providerId
14671 
    self.deliveredOrders = deliveredOrders
304 ashish 14672 
 
14673 
  def read(self, iprot):
14674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14676 
      return
14677 
    iprot.readStructBegin()
14678 
    while True:
14679 
      (fname, ftype, fid) = iprot.readFieldBegin()
14680 
      if ftype == TType.STOP:
14681 
        break
14682 
      if fid == 1:
14683 
        if ftype == TType.I64:
3064 chandransh 14684 
          self.providerId = iprot.readI64();
304 ashish 14685 
        else:
14686 
          iprot.skip(ftype)
14687 
      elif fid == 2:
3064 chandransh 14688 
        if ftype == TType.MAP:
14689 
          self.deliveredOrders = {}
6188 rajveer 14690 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14691 
          for _i322 in xrange(_size318):
14692 
            _key323 = iprot.readString();
14693 
            _val324 = iprot.readString();
14694 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14695 
          iprot.readMapEnd()
304 ashish 14696 
        else:
14697 
          iprot.skip(ftype)
14698 
      else:
14699 
        iprot.skip(ftype)
14700 
      iprot.readFieldEnd()
14701 
    iprot.readStructEnd()
14702 
 
14703 
  def write(self, oprot):
14704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14706 
      return
3064 chandransh 14707 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14708 
    if self.providerId is not None:
3064 chandransh 14709 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14710 
      oprot.writeI64(self.providerId)
304 ashish 14711 
      oprot.writeFieldEnd()
3431 rajveer 14712 
    if self.deliveredOrders is not None:
3064 chandransh 14713 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14714 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14715 
      for kiter325,viter326 in self.deliveredOrders.items():
14716 
        oprot.writeString(kiter325)
14717 
        oprot.writeString(viter326)
3064 chandransh 14718 
      oprot.writeMapEnd()
304 ashish 14719 
      oprot.writeFieldEnd()
14720 
    oprot.writeFieldStop()
14721 
    oprot.writeStructEnd()
14722 
 
3431 rajveer 14723 
  def validate(self):
14724 
    return
14725 
 
14726 
 
304 ashish 14727 
  def __repr__(self):
14728 
    L = ['%s=%r' % (key, value)
14729 
      for key, value in self.__dict__.iteritems()]
14730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14731 
 
14732 
  def __eq__(self, other):
14733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14734 
 
14735 
  def __ne__(self, other):
14736 
    return not (self == other)
14737 
 
3064 chandransh 14738 
class markOrdersAsDelivered_result:
14739 
  """
14740 
  Attributes:
14741 
   - ex
14742 
  """
304 ashish 14743 
 
14744 
  thrift_spec = (
3064 chandransh 14745 
    None, # 0
14746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14747 
  )
14748 
 
3064 chandransh 14749 
  def __init__(self, ex=None,):
14750 
    self.ex = ex
304 ashish 14751 
 
1596 ankur.sing 14752 
  def read(self, iprot):
14753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14755 
      return
14756 
    iprot.readStructBegin()
14757 
    while True:
14758 
      (fname, ftype, fid) = iprot.readFieldBegin()
14759 
      if ftype == TType.STOP:
14760 
        break
3064 chandransh 14761 
      if fid == 1:
14762 
        if ftype == TType.STRUCT:
14763 
          self.ex = TransactionServiceException()
14764 
          self.ex.read(iprot)
14765 
        else:
14766 
          iprot.skip(ftype)
1596 ankur.sing 14767 
      else:
14768 
        iprot.skip(ftype)
14769 
      iprot.readFieldEnd()
14770 
    iprot.readStructEnd()
14771 
 
14772 
  def write(self, oprot):
14773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14775 
      return
3064 chandransh 14776 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14777 
    if self.ex is not None:
3064 chandransh 14778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14779 
      self.ex.write(oprot)
14780 
      oprot.writeFieldEnd()
1596 ankur.sing 14781 
    oprot.writeFieldStop()
14782 
    oprot.writeStructEnd()
14783 
 
3431 rajveer 14784 
  def validate(self):
14785 
    return
14786 
 
14787 
 
1596 ankur.sing 14788 
  def __repr__(self):
14789 
    L = ['%s=%r' % (key, value)
14790 
      for key, value in self.__dict__.iteritems()]
14791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14792 
 
14793 
  def __eq__(self, other):
14794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14795 
 
14796 
  def __ne__(self, other):
14797 
    return not (self == other)
14798 
 
4910 phani.kuma 14799 
class markAsRTOrders_args:
1596 ankur.sing 14800 
  """
14801 
  Attributes:
3064 chandransh 14802 
   - providerId
14803 
   - returnedOrders
1596 ankur.sing 14804 
  """
14805 
 
14806 
  thrift_spec = (
3064 chandransh 14807 
    None, # 0
14808 
    (1, TType.I64, 'providerId', None, None, ), # 1
14809 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14810 
  )
14811 
 
3064 chandransh 14812 
  def __init__(self, providerId=None, returnedOrders=None,):
14813 
    self.providerId = providerId
14814 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14815 
 
14816 
  def read(self, iprot):
14817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14819 
      return
14820 
    iprot.readStructBegin()
14821 
    while True:
14822 
      (fname, ftype, fid) = iprot.readFieldBegin()
14823 
      if ftype == TType.STOP:
14824 
        break
3064 chandransh 14825 
      if fid == 1:
1596 ankur.sing 14826 
        if ftype == TType.I64:
3064 chandransh 14827 
          self.providerId = iprot.readI64();
1596 ankur.sing 14828 
        else:
14829 
          iprot.skip(ftype)
3064 chandransh 14830 
      elif fid == 2:
14831 
        if ftype == TType.MAP:
14832 
          self.returnedOrders = {}
6188 rajveer 14833 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14834 
          for _i331 in xrange(_size327):
14835 
            _key332 = iprot.readString();
14836 
            _val333 = iprot.readString();
14837 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14838 
          iprot.readMapEnd()
14839 
        else:
14840 
          iprot.skip(ftype)
1596 ankur.sing 14841 
      else:
14842 
        iprot.skip(ftype)
14843 
      iprot.readFieldEnd()
14844 
    iprot.readStructEnd()
14845 
 
14846 
  def write(self, oprot):
14847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14849 
      return
4910 phani.kuma 14850 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14851 
    if self.providerId is not None:
3064 chandransh 14852 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14853 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14854 
      oprot.writeFieldEnd()
3431 rajveer 14855 
    if self.returnedOrders is not None:
3064 chandransh 14856 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14857 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14858 
      for kiter334,viter335 in self.returnedOrders.items():
14859 
        oprot.writeString(kiter334)
14860 
        oprot.writeString(viter335)
3064 chandransh 14861 
      oprot.writeMapEnd()
14862 
      oprot.writeFieldEnd()
1596 ankur.sing 14863 
    oprot.writeFieldStop()
14864 
    oprot.writeStructEnd()
14865 
 
3431 rajveer 14866 
  def validate(self):
14867 
    return
14868 
 
14869 
 
1596 ankur.sing 14870 
  def __repr__(self):
14871 
    L = ['%s=%r' % (key, value)
14872 
      for key, value in self.__dict__.iteritems()]
14873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14874 
 
14875 
  def __eq__(self, other):
14876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14877 
 
14878 
  def __ne__(self, other):
14879 
    return not (self == other)
14880 
 
4910 phani.kuma 14881 
class markAsRTOrders_result:
3064 chandransh 14882 
  """
14883 
  Attributes:
14884 
   - ex
14885 
  """
1596 ankur.sing 14886 
 
1627 ankur.sing 14887 
  thrift_spec = (
3064 chandransh 14888 
    None, # 0
14889 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14890 
  )
14891 
 
3064 chandransh 14892 
  def __init__(self, ex=None,):
14893 
    self.ex = ex
14894 
 
1627 ankur.sing 14895 
  def read(self, iprot):
14896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14898 
      return
14899 
    iprot.readStructBegin()
14900 
    while True:
14901 
      (fname, ftype, fid) = iprot.readFieldBegin()
14902 
      if ftype == TType.STOP:
14903 
        break
3064 chandransh 14904 
      if fid == 1:
14905 
        if ftype == TType.STRUCT:
14906 
          self.ex = TransactionServiceException()
14907 
          self.ex.read(iprot)
14908 
        else:
14909 
          iprot.skip(ftype)
1627 ankur.sing 14910 
      else:
14911 
        iprot.skip(ftype)
14912 
      iprot.readFieldEnd()
14913 
    iprot.readStructEnd()
14914 
 
14915 
  def write(self, oprot):
14916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14918 
      return
4910 phani.kuma 14919 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14920 
    if self.ex is not None:
3064 chandransh 14921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14922 
      self.ex.write(oprot)
14923 
      oprot.writeFieldEnd()
1627 ankur.sing 14924 
    oprot.writeFieldStop()
14925 
    oprot.writeStructEnd()
14926 
 
3431 rajveer 14927 
  def validate(self):
14928 
    return
14929 
 
14930 
 
1627 ankur.sing 14931 
  def __repr__(self):
14932 
    L = ['%s=%r' % (key, value)
14933 
      for key, value in self.__dict__.iteritems()]
14934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14935 
 
14936 
  def __eq__(self, other):
14937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14938 
 
14939 
  def __ne__(self, other):
14940 
    return not (self == other)
14941 
 
4910 phani.kuma 14942 
class getRTOrders_args:
14943 
  """
14944 
  Attributes:
14945 
   - providerId
14946 
  """
14947 
 
14948 
  thrift_spec = (
14949 
    None, # 0
14950 
    (1, TType.I64, 'providerId', None, None, ), # 1
14951 
  )
14952 
 
14953 
  def __init__(self, providerId=None,):
14954 
    self.providerId = providerId
14955 
 
14956 
  def read(self, iprot):
14957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14959 
      return
14960 
    iprot.readStructBegin()
14961 
    while True:
14962 
      (fname, ftype, fid) = iprot.readFieldBegin()
14963 
      if ftype == TType.STOP:
14964 
        break
14965 
      if fid == 1:
14966 
        if ftype == TType.I64:
14967 
          self.providerId = iprot.readI64();
14968 
        else:
14969 
          iprot.skip(ftype)
14970 
      else:
14971 
        iprot.skip(ftype)
14972 
      iprot.readFieldEnd()
14973 
    iprot.readStructEnd()
14974 
 
14975 
  def write(self, oprot):
14976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14978 
      return
14979 
    oprot.writeStructBegin('getRTOrders_args')
14980 
    if self.providerId is not None:
14981 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14982 
      oprot.writeI64(self.providerId)
14983 
      oprot.writeFieldEnd()
14984 
    oprot.writeFieldStop()
14985 
    oprot.writeStructEnd()
14986 
 
14987 
  def validate(self):
14988 
    return
14989 
 
14990 
 
14991 
  def __repr__(self):
14992 
    L = ['%s=%r' % (key, value)
14993 
      for key, value in self.__dict__.iteritems()]
14994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14995 
 
14996 
  def __eq__(self, other):
14997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14998 
 
14999 
  def __ne__(self, other):
15000 
    return not (self == other)
15001 
 
15002 
class getRTOrders_result:
15003 
  """
15004 
  Attributes:
15005 
   - success
15006 
  """
15007 
 
15008 
  thrift_spec = (
15009 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15010 
  )
15011 
 
15012 
  def __init__(self, success=None,):
15013 
    self.success = success
15014 
 
15015 
  def read(self, iprot):
15016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15018 
      return
15019 
    iprot.readStructBegin()
15020 
    while True:
15021 
      (fname, ftype, fid) = iprot.readFieldBegin()
15022 
      if ftype == TType.STOP:
15023 
        break
15024 
      if fid == 0:
15025 
        if ftype == TType.LIST:
15026 
          self.success = []
6188 rajveer 15027 
          (_etype339, _size336) = iprot.readListBegin()
15028 
          for _i340 in xrange(_size336):
15029 
            _elem341 = Order()
15030 
            _elem341.read(iprot)
15031 
            self.success.append(_elem341)
4910 phani.kuma 15032 
          iprot.readListEnd()
15033 
        else:
15034 
          iprot.skip(ftype)
15035 
      else:
15036 
        iprot.skip(ftype)
15037 
      iprot.readFieldEnd()
15038 
    iprot.readStructEnd()
15039 
 
15040 
  def write(self, oprot):
15041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15043 
      return
15044 
    oprot.writeStructBegin('getRTOrders_result')
15045 
    if self.success is not None:
15046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15047 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15048 
      for iter342 in self.success:
15049 
        iter342.write(oprot)
4910 phani.kuma 15050 
      oprot.writeListEnd()
15051 
      oprot.writeFieldEnd()
15052 
    oprot.writeFieldStop()
15053 
    oprot.writeStructEnd()
15054 
 
15055 
  def validate(self):
15056 
    return
15057 
 
15058 
 
15059 
  def __repr__(self):
15060 
    L = ['%s=%r' % (key, value)
15061 
      for key, value in self.__dict__.iteritems()]
15062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15063 
 
15064 
  def __eq__(self, other):
15065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15066 
 
15067 
  def __ne__(self, other):
15068 
    return not (self == other)
15069 
 
3064 chandransh 15070 
class updateNonDeliveryReason_args:
1627 ankur.sing 15071 
  """
15072 
  Attributes:
3064 chandransh 15073 
   - providerId
15074 
   - undeliveredOrders
1627 ankur.sing 15075 
  """
15076 
 
15077 
  thrift_spec = (
3064 chandransh 15078 
    None, # 0
15079 
    (1, TType.I64, 'providerId', None, None, ), # 1
15080 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15081 
  )
15082 
 
3064 chandransh 15083 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15084 
    self.providerId = providerId
15085 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15086 
 
15087 
  def read(self, iprot):
15088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15090 
      return
15091 
    iprot.readStructBegin()
15092 
    while True:
15093 
      (fname, ftype, fid) = iprot.readFieldBegin()
15094 
      if ftype == TType.STOP:
15095 
        break
3064 chandransh 15096 
      if fid == 1:
1627 ankur.sing 15097 
        if ftype == TType.I64:
3064 chandransh 15098 
          self.providerId = iprot.readI64();
1627 ankur.sing 15099 
        else:
15100 
          iprot.skip(ftype)
3064 chandransh 15101 
      elif fid == 2:
15102 
        if ftype == TType.MAP:
15103 
          self.undeliveredOrders = {}
6188 rajveer 15104 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15105 
          for _i347 in xrange(_size343):
15106 
            _key348 = iprot.readString();
15107 
            _val349 = iprot.readString();
15108 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15109 
          iprot.readMapEnd()
15110 
        else:
15111 
          iprot.skip(ftype)
1627 ankur.sing 15112 
      else:
15113 
        iprot.skip(ftype)
15114 
      iprot.readFieldEnd()
15115 
    iprot.readStructEnd()
15116 
 
15117 
  def write(self, oprot):
15118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15120 
      return
3064 chandransh 15121 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15122 
    if self.providerId is not None:
3064 chandransh 15123 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15124 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15125 
      oprot.writeFieldEnd()
3431 rajveer 15126 
    if self.undeliveredOrders is not None:
3064 chandransh 15127 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15128 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15129 
      for kiter350,viter351 in self.undeliveredOrders.items():
15130 
        oprot.writeString(kiter350)
15131 
        oprot.writeString(viter351)
3064 chandransh 15132 
      oprot.writeMapEnd()
15133 
      oprot.writeFieldEnd()
1627 ankur.sing 15134 
    oprot.writeFieldStop()
15135 
    oprot.writeStructEnd()
15136 
 
3431 rajveer 15137 
  def validate(self):
15138 
    return
15139 
 
15140 
 
1627 ankur.sing 15141 
  def __repr__(self):
15142 
    L = ['%s=%r' % (key, value)
15143 
      for key, value in self.__dict__.iteritems()]
15144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15145 
 
15146 
  def __eq__(self, other):
15147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15148 
 
15149 
  def __ne__(self, other):
15150 
    return not (self == other)
15151 
 
3064 chandransh 15152 
class updateNonDeliveryReason_result:
1627 ankur.sing 15153 
  """
15154 
  Attributes:
3064 chandransh 15155 
   - ex
1627 ankur.sing 15156 
  """
15157 
 
15158 
  thrift_spec = (
4910 phani.kuma 15159 
    None, # 0
3064 chandransh 15160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15161 
  )
15162 
 
4910 phani.kuma 15163 
  def __init__(self, ex=None,):
3064 chandransh 15164 
    self.ex = ex
1627 ankur.sing 15165 
 
15166 
  def read(self, iprot):
15167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15169 
      return
15170 
    iprot.readStructBegin()
15171 
    while True:
15172 
      (fname, ftype, fid) = iprot.readFieldBegin()
15173 
      if ftype == TType.STOP:
15174 
        break
4910 phani.kuma 15175 
      if fid == 1:
15176 
        if ftype == TType.STRUCT:
15177 
          self.ex = TransactionServiceException()
15178 
          self.ex.read(iprot)
15179 
        else:
15180 
          iprot.skip(ftype)
15181 
      else:
15182 
        iprot.skip(ftype)
15183 
      iprot.readFieldEnd()
15184 
    iprot.readStructEnd()
15185 
 
15186 
  def write(self, oprot):
15187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15189 
      return
15190 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15191 
    if self.ex is not None:
15192 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15193 
      self.ex.write(oprot)
15194 
      oprot.writeFieldEnd()
15195 
    oprot.writeFieldStop()
15196 
    oprot.writeStructEnd()
15197 
 
15198 
  def validate(self):
15199 
    return
15200 
 
15201 
 
15202 
  def __repr__(self):
15203 
    L = ['%s=%r' % (key, value)
15204 
      for key, value in self.__dict__.iteritems()]
15205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15206 
 
15207 
  def __eq__(self, other):
15208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15209 
 
15210 
  def __ne__(self, other):
15211 
    return not (self == other)
15212 
 
15213 
class getNonDeliveredOrdersbyCourier_args:
15214 
  """
15215 
  Attributes:
15216 
   - providerId
15217 
  """
15218 
 
15219 
  thrift_spec = (
15220 
    None, # 0
15221 
    (1, TType.I64, 'providerId', None, None, ), # 1
15222 
  )
15223 
 
15224 
  def __init__(self, providerId=None,):
15225 
    self.providerId = providerId
15226 
 
15227 
  def read(self, iprot):
15228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15230 
      return
15231 
    iprot.readStructBegin()
15232 
    while True:
15233 
      (fname, ftype, fid) = iprot.readFieldBegin()
15234 
      if ftype == TType.STOP:
15235 
        break
15236 
      if fid == 1:
15237 
        if ftype == TType.I64:
15238 
          self.providerId = iprot.readI64();
15239 
        else:
15240 
          iprot.skip(ftype)
15241 
      else:
15242 
        iprot.skip(ftype)
15243 
      iprot.readFieldEnd()
15244 
    iprot.readStructEnd()
15245 
 
15246 
  def write(self, oprot):
15247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15249 
      return
15250 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15251 
    if self.providerId is not None:
15252 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15253 
      oprot.writeI64(self.providerId)
15254 
      oprot.writeFieldEnd()
15255 
    oprot.writeFieldStop()
15256 
    oprot.writeStructEnd()
15257 
 
15258 
  def validate(self):
15259 
    return
15260 
 
15261 
 
15262 
  def __repr__(self):
15263 
    L = ['%s=%r' % (key, value)
15264 
      for key, value in self.__dict__.iteritems()]
15265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15266 
 
15267 
  def __eq__(self, other):
15268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15269 
 
15270 
  def __ne__(self, other):
15271 
    return not (self == other)
15272 
 
15273 
class getNonDeliveredOrdersbyCourier_result:
15274 
  """
15275 
  Attributes:
15276 
   - success
15277 
  """
15278 
 
15279 
  thrift_spec = (
15280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15281 
  )
15282 
 
15283 
  def __init__(self, success=None,):
15284 
    self.success = success
15285 
 
15286 
  def read(self, iprot):
15287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15289 
      return
15290 
    iprot.readStructBegin()
15291 
    while True:
15292 
      (fname, ftype, fid) = iprot.readFieldBegin()
15293 
      if ftype == TType.STOP:
15294 
        break
4581 phani.kuma 15295 
      if fid == 0:
15296 
        if ftype == TType.LIST:
15297 
          self.success = []
6188 rajveer 15298 
          (_etype355, _size352) = iprot.readListBegin()
15299 
          for _i356 in xrange(_size352):
15300 
            _elem357 = Order()
15301 
            _elem357.read(iprot)
15302 
            self.success.append(_elem357)
4581 phani.kuma 15303 
          iprot.readListEnd()
15304 
        else:
15305 
          iprot.skip(ftype)
4910 phani.kuma 15306 
      else:
15307 
        iprot.skip(ftype)
15308 
      iprot.readFieldEnd()
15309 
    iprot.readStructEnd()
15310 
 
15311 
  def write(self, oprot):
15312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15314 
      return
15315 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15316 
    if self.success is not None:
15317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15319 
      for iter358 in self.success:
15320 
        iter358.write(oprot)
4910 phani.kuma 15321 
      oprot.writeListEnd()
15322 
      oprot.writeFieldEnd()
15323 
    oprot.writeFieldStop()
15324 
    oprot.writeStructEnd()
15325 
 
15326 
  def validate(self):
15327 
    return
15328 
 
15329 
 
15330 
  def __repr__(self):
15331 
    L = ['%s=%r' % (key, value)
15332 
      for key, value in self.__dict__.iteritems()]
15333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15334 
 
15335 
  def __eq__(self, other):
15336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15337 
 
15338 
  def __ne__(self, other):
15339 
    return not (self == other)
15340 
 
15341 
class markOrdersAsLocalConnected_args:
15342 
  """
15343 
  Attributes:
15344 
   - providerId
15345 
   - local_connected_orders
15346 
  """
15347 
 
15348 
  thrift_spec = (
15349 
    None, # 0
15350 
    (1, TType.I64, 'providerId', None, None, ), # 1
15351 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15352 
  )
15353 
 
15354 
  def __init__(self, providerId=None, local_connected_orders=None,):
15355 
    self.providerId = providerId
15356 
    self.local_connected_orders = local_connected_orders
15357 
 
15358 
  def read(self, iprot):
15359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15361 
      return
15362 
    iprot.readStructBegin()
15363 
    while True:
15364 
      (fname, ftype, fid) = iprot.readFieldBegin()
15365 
      if ftype == TType.STOP:
15366 
        break
15367 
      if fid == 1:
15368 
        if ftype == TType.I64:
15369 
          self.providerId = iprot.readI64();
15370 
        else:
15371 
          iprot.skip(ftype)
15372 
      elif fid == 2:
15373 
        if ftype == TType.MAP:
15374 
          self.local_connected_orders = {}
6188 rajveer 15375 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15376 
          for _i363 in xrange(_size359):
15377 
            _key364 = iprot.readString();
15378 
            _val365 = iprot.readString();
15379 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15380 
          iprot.readMapEnd()
15381 
        else:
15382 
          iprot.skip(ftype)
15383 
      else:
15384 
        iprot.skip(ftype)
15385 
      iprot.readFieldEnd()
15386 
    iprot.readStructEnd()
15387 
 
15388 
  def write(self, oprot):
15389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15391 
      return
15392 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15393 
    if self.providerId is not None:
15394 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15395 
      oprot.writeI64(self.providerId)
15396 
      oprot.writeFieldEnd()
15397 
    if self.local_connected_orders is not None:
15398 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15399 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15400 
      for kiter366,viter367 in self.local_connected_orders.items():
15401 
        oprot.writeString(kiter366)
15402 
        oprot.writeString(viter367)
4910 phani.kuma 15403 
      oprot.writeMapEnd()
15404 
      oprot.writeFieldEnd()
15405 
    oprot.writeFieldStop()
15406 
    oprot.writeStructEnd()
15407 
 
15408 
  def validate(self):
15409 
    return
15410 
 
15411 
 
15412 
  def __repr__(self):
15413 
    L = ['%s=%r' % (key, value)
15414 
      for key, value in self.__dict__.iteritems()]
15415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15416 
 
15417 
  def __eq__(self, other):
15418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15419 
 
15420 
  def __ne__(self, other):
15421 
    return not (self == other)
15422 
 
15423 
class markOrdersAsLocalConnected_result:
15424 
  """
15425 
  Attributes:
15426 
   - ex
15427 
  """
15428 
 
15429 
  thrift_spec = (
15430 
    None, # 0
15431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15432 
  )
15433 
 
15434 
  def __init__(self, ex=None,):
15435 
    self.ex = ex
15436 
 
15437 
  def read(self, iprot):
15438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15440 
      return
15441 
    iprot.readStructBegin()
15442 
    while True:
15443 
      (fname, ftype, fid) = iprot.readFieldBegin()
15444 
      if ftype == TType.STOP:
15445 
        break
15446 
      if fid == 1:
3064 chandransh 15447 
        if ftype == TType.STRUCT:
15448 
          self.ex = TransactionServiceException()
15449 
          self.ex.read(iprot)
1627 ankur.sing 15450 
        else:
15451 
          iprot.skip(ftype)
15452 
      else:
15453 
        iprot.skip(ftype)
15454 
      iprot.readFieldEnd()
15455 
    iprot.readStructEnd()
15456 
 
15457 
  def write(self, oprot):
15458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15460 
      return
4910 phani.kuma 15461 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15462 
    if self.ex is not None:
15463 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15464 
      self.ex.write(oprot)
15465 
      oprot.writeFieldEnd()
15466 
    oprot.writeFieldStop()
15467 
    oprot.writeStructEnd()
15468 
 
15469 
  def validate(self):
15470 
    return
15471 
 
15472 
 
15473 
  def __repr__(self):
15474 
    L = ['%s=%r' % (key, value)
15475 
      for key, value in self.__dict__.iteritems()]
15476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15477 
 
15478 
  def __eq__(self, other):
15479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15480 
 
15481 
  def __ne__(self, other):
15482 
    return not (self == other)
15483 
 
15484 
class getOrdersNotLocalConnected_args:
15485 
  """
15486 
  Attributes:
15487 
   - providerId
15488 
  """
15489 
 
15490 
  thrift_spec = (
15491 
    None, # 0
15492 
    (1, TType.I64, 'providerId', None, None, ), # 1
15493 
  )
15494 
 
15495 
  def __init__(self, providerId=None,):
15496 
    self.providerId = providerId
15497 
 
15498 
  def read(self, iprot):
15499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15501 
      return
15502 
    iprot.readStructBegin()
15503 
    while True:
15504 
      (fname, ftype, fid) = iprot.readFieldBegin()
15505 
      if ftype == TType.STOP:
15506 
        break
15507 
      if fid == 1:
15508 
        if ftype == TType.I64:
15509 
          self.providerId = iprot.readI64();
15510 
        else:
15511 
          iprot.skip(ftype)
15512 
      else:
15513 
        iprot.skip(ftype)
15514 
      iprot.readFieldEnd()
15515 
    iprot.readStructEnd()
15516 
 
15517 
  def write(self, oprot):
15518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15520 
      return
15521 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15522 
    if self.providerId is not None:
15523 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15524 
      oprot.writeI64(self.providerId)
15525 
      oprot.writeFieldEnd()
15526 
    oprot.writeFieldStop()
15527 
    oprot.writeStructEnd()
15528 
 
15529 
  def validate(self):
15530 
    return
15531 
 
15532 
 
15533 
  def __repr__(self):
15534 
    L = ['%s=%r' % (key, value)
15535 
      for key, value in self.__dict__.iteritems()]
15536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15537 
 
15538 
  def __eq__(self, other):
15539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15540 
 
15541 
  def __ne__(self, other):
15542 
    return not (self == other)
15543 
 
15544 
class getOrdersNotLocalConnected_result:
15545 
  """
15546 
  Attributes:
15547 
   - success
15548 
  """
15549 
 
15550 
  thrift_spec = (
15551 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15552 
  )
15553 
 
15554 
  def __init__(self, success=None,):
15555 
    self.success = success
15556 
 
15557 
  def read(self, iprot):
15558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15560 
      return
15561 
    iprot.readStructBegin()
15562 
    while True:
15563 
      (fname, ftype, fid) = iprot.readFieldBegin()
15564 
      if ftype == TType.STOP:
15565 
        break
15566 
      if fid == 0:
15567 
        if ftype == TType.LIST:
15568 
          self.success = []
6188 rajveer 15569 
          (_etype371, _size368) = iprot.readListBegin()
15570 
          for _i372 in xrange(_size368):
15571 
            _elem373 = Order()
15572 
            _elem373.read(iprot)
15573 
            self.success.append(_elem373)
4910 phani.kuma 15574 
          iprot.readListEnd()
15575 
        else:
15576 
          iprot.skip(ftype)
15577 
      else:
15578 
        iprot.skip(ftype)
15579 
      iprot.readFieldEnd()
15580 
    iprot.readStructEnd()
15581 
 
15582 
  def write(self, oprot):
15583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15585 
      return
15586 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15587 
    if self.success is not None:
15588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15589 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15590 
      for iter374 in self.success:
15591 
        iter374.write(oprot)
4581 phani.kuma 15592 
      oprot.writeListEnd()
15593 
      oprot.writeFieldEnd()
4910 phani.kuma 15594 
    oprot.writeFieldStop()
15595 
    oprot.writeStructEnd()
15596 
 
15597 
  def validate(self):
15598 
    return
15599 
 
15600 
 
15601 
  def __repr__(self):
15602 
    L = ['%s=%r' % (key, value)
15603 
      for key, value in self.__dict__.iteritems()]
15604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15605 
 
15606 
  def __eq__(self, other):
15607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15608 
 
15609 
  def __ne__(self, other):
15610 
    return not (self == other)
15611 
 
15612 
class markOrdersAsDestinationCityReached_args:
15613 
  """
15614 
  Attributes:
15615 
   - providerId
15616 
   - destination_city_reached_orders
15617 
  """
15618 
 
15619 
  thrift_spec = (
15620 
    None, # 0
15621 
    (1, TType.I64, 'providerId', None, None, ), # 1
15622 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15623 
  )
15624 
 
15625 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15626 
    self.providerId = providerId
15627 
    self.destination_city_reached_orders = destination_city_reached_orders
15628 
 
15629 
  def read(self, iprot):
15630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15632 
      return
15633 
    iprot.readStructBegin()
15634 
    while True:
15635 
      (fname, ftype, fid) = iprot.readFieldBegin()
15636 
      if ftype == TType.STOP:
15637 
        break
15638 
      if fid == 1:
15639 
        if ftype == TType.I64:
15640 
          self.providerId = iprot.readI64();
15641 
        else:
15642 
          iprot.skip(ftype)
15643 
      elif fid == 2:
15644 
        if ftype == TType.MAP:
15645 
          self.destination_city_reached_orders = {}
6188 rajveer 15646 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15647 
          for _i379 in xrange(_size375):
15648 
            _key380 = iprot.readString();
15649 
            _val381 = iprot.readString();
15650 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15651 
          iprot.readMapEnd()
15652 
        else:
15653 
          iprot.skip(ftype)
15654 
      else:
15655 
        iprot.skip(ftype)
15656 
      iprot.readFieldEnd()
15657 
    iprot.readStructEnd()
15658 
 
15659 
  def write(self, oprot):
15660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15662 
      return
15663 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15664 
    if self.providerId is not None:
15665 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15666 
      oprot.writeI64(self.providerId)
15667 
      oprot.writeFieldEnd()
15668 
    if self.destination_city_reached_orders is not None:
15669 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15670 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15671 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15672 
        oprot.writeString(kiter382)
15673 
        oprot.writeString(viter383)
4910 phani.kuma 15674 
      oprot.writeMapEnd()
15675 
      oprot.writeFieldEnd()
15676 
    oprot.writeFieldStop()
15677 
    oprot.writeStructEnd()
15678 
 
15679 
  def validate(self):
15680 
    return
15681 
 
15682 
 
15683 
  def __repr__(self):
15684 
    L = ['%s=%r' % (key, value)
15685 
      for key, value in self.__dict__.iteritems()]
15686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15687 
 
15688 
  def __eq__(self, other):
15689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15690 
 
15691 
  def __ne__(self, other):
15692 
    return not (self == other)
15693 
 
15694 
class markOrdersAsDestinationCityReached_result:
15695 
  """
15696 
  Attributes:
15697 
   - ex
15698 
  """
15699 
 
15700 
  thrift_spec = (
15701 
    None, # 0
15702 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15703 
  )
15704 
 
15705 
  def __init__(self, ex=None,):
15706 
    self.ex = ex
15707 
 
15708 
  def read(self, iprot):
15709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15711 
      return
15712 
    iprot.readStructBegin()
15713 
    while True:
15714 
      (fname, ftype, fid) = iprot.readFieldBegin()
15715 
      if ftype == TType.STOP:
15716 
        break
15717 
      if fid == 1:
15718 
        if ftype == TType.STRUCT:
15719 
          self.ex = TransactionServiceException()
15720 
          self.ex.read(iprot)
15721 
        else:
15722 
          iprot.skip(ftype)
15723 
      else:
15724 
        iprot.skip(ftype)
15725 
      iprot.readFieldEnd()
15726 
    iprot.readStructEnd()
15727 
 
15728 
  def write(self, oprot):
15729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15731 
      return
15732 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15733 
    if self.ex is not None:
3064 chandransh 15734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15735 
      self.ex.write(oprot)
1627 ankur.sing 15736 
      oprot.writeFieldEnd()
15737 
    oprot.writeFieldStop()
15738 
    oprot.writeStructEnd()
15739 
 
3431 rajveer 15740 
  def validate(self):
15741 
    return
15742 
 
15743 
 
1627 ankur.sing 15744 
  def __repr__(self):
15745 
    L = ['%s=%r' % (key, value)
15746 
      for key, value in self.__dict__.iteritems()]
15747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15748 
 
15749 
  def __eq__(self, other):
15750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15751 
 
15752 
  def __ne__(self, other):
15753 
    return not (self == other)
15754 
 
4910 phani.kuma 15755 
class markOrdersAsFirstDeliveryAttempted_args:
15756 
  """
15757 
  Attributes:
15758 
   - providerId
15759 
   - first_atdl_orders
15760 
  """
15761 
 
15762 
  thrift_spec = (
15763 
    None, # 0
15764 
    (1, TType.I64, 'providerId', None, None, ), # 1
15765 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15766 
  )
15767 
 
15768 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15769 
    self.providerId = providerId
15770 
    self.first_atdl_orders = first_atdl_orders
15771 
 
15772 
  def read(self, iprot):
15773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15775 
      return
15776 
    iprot.readStructBegin()
15777 
    while True:
15778 
      (fname, ftype, fid) = iprot.readFieldBegin()
15779 
      if ftype == TType.STOP:
15780 
        break
15781 
      if fid == 1:
15782 
        if ftype == TType.I64:
15783 
          self.providerId = iprot.readI64();
15784 
        else:
15785 
          iprot.skip(ftype)
15786 
      elif fid == 2:
15787 
        if ftype == TType.MAP:
15788 
          self.first_atdl_orders = {}
6188 rajveer 15789 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15790 
          for _i388 in xrange(_size384):
15791 
            _key389 = iprot.readString();
15792 
            _val390 = iprot.readString();
15793 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15794 
          iprot.readMapEnd()
15795 
        else:
15796 
          iprot.skip(ftype)
15797 
      else:
15798 
        iprot.skip(ftype)
15799 
      iprot.readFieldEnd()
15800 
    iprot.readStructEnd()
15801 
 
15802 
  def write(self, oprot):
15803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15805 
      return
15806 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15807 
    if self.providerId is not None:
15808 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15809 
      oprot.writeI64(self.providerId)
15810 
      oprot.writeFieldEnd()
15811 
    if self.first_atdl_orders is not None:
15812 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15813 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15814 
      for kiter391,viter392 in self.first_atdl_orders.items():
15815 
        oprot.writeString(kiter391)
15816 
        oprot.writeString(viter392)
4910 phani.kuma 15817 
      oprot.writeMapEnd()
15818 
      oprot.writeFieldEnd()
15819 
    oprot.writeFieldStop()
15820 
    oprot.writeStructEnd()
15821 
 
15822 
  def validate(self):
15823 
    return
15824 
 
15825 
 
15826 
  def __repr__(self):
15827 
    L = ['%s=%r' % (key, value)
15828 
      for key, value in self.__dict__.iteritems()]
15829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15830 
 
15831 
  def __eq__(self, other):
15832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15833 
 
15834 
  def __ne__(self, other):
15835 
    return not (self == other)
15836 
 
15837 
class markOrdersAsFirstDeliveryAttempted_result:
15838 
  """
15839 
  Attributes:
15840 
   - ex
15841 
  """
15842 
 
15843 
  thrift_spec = (
15844 
    None, # 0
15845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15846 
  )
15847 
 
15848 
  def __init__(self, ex=None,):
15849 
    self.ex = ex
15850 
 
15851 
  def read(self, iprot):
15852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15854 
      return
15855 
    iprot.readStructBegin()
15856 
    while True:
15857 
      (fname, ftype, fid) = iprot.readFieldBegin()
15858 
      if ftype == TType.STOP:
15859 
        break
15860 
      if fid == 1:
15861 
        if ftype == TType.STRUCT:
15862 
          self.ex = TransactionServiceException()
15863 
          self.ex.read(iprot)
15864 
        else:
15865 
          iprot.skip(ftype)
15866 
      else:
15867 
        iprot.skip(ftype)
15868 
      iprot.readFieldEnd()
15869 
    iprot.readStructEnd()
15870 
 
15871 
  def write(self, oprot):
15872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15874 
      return
15875 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15876 
    if self.ex is not None:
15877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15878 
      self.ex.write(oprot)
15879 
      oprot.writeFieldEnd()
15880 
    oprot.writeFieldStop()
15881 
    oprot.writeStructEnd()
15882 
 
15883 
  def validate(self):
15884 
    return
15885 
 
15886 
 
15887 
  def __repr__(self):
15888 
    L = ['%s=%r' % (key, value)
15889 
      for key, value in self.__dict__.iteritems()]
15890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15891 
 
15892 
  def __eq__(self, other):
15893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15894 
 
15895 
  def __ne__(self, other):
15896 
    return not (self == other)
15897 
 
3064 chandransh 15898 
class getUndeliveredOrders_args:
1886 ankur.sing 15899 
  """
15900 
  Attributes:
3064 chandransh 15901 
   - providerId
15902 
   - warehouseId
1886 ankur.sing 15903 
  """
1627 ankur.sing 15904 
 
1886 ankur.sing 15905 
  thrift_spec = (
15906 
    None, # 0
3064 chandransh 15907 
    (1, TType.I64, 'providerId', None, None, ), # 1
15908 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15909 
  )
15910 
 
3064 chandransh 15911 
  def __init__(self, providerId=None, warehouseId=None,):
15912 
    self.providerId = providerId
15913 
    self.warehouseId = warehouseId
1886 ankur.sing 15914 
 
15915 
  def read(self, iprot):
15916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15918 
      return
15919 
    iprot.readStructBegin()
15920 
    while True:
15921 
      (fname, ftype, fid) = iprot.readFieldBegin()
15922 
      if ftype == TType.STOP:
15923 
        break
15924 
      if fid == 1:
15925 
        if ftype == TType.I64:
3064 chandransh 15926 
          self.providerId = iprot.readI64();
1886 ankur.sing 15927 
        else:
15928 
          iprot.skip(ftype)
3064 chandransh 15929 
      elif fid == 2:
15930 
        if ftype == TType.I64:
15931 
          self.warehouseId = iprot.readI64();
15932 
        else:
15933 
          iprot.skip(ftype)
1886 ankur.sing 15934 
      else:
15935 
        iprot.skip(ftype)
15936 
      iprot.readFieldEnd()
15937 
    iprot.readStructEnd()
15938 
 
15939 
  def write(self, oprot):
15940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15942 
      return
3064 chandransh 15943 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15944 
    if self.providerId is not None:
3064 chandransh 15945 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15946 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15947 
      oprot.writeFieldEnd()
3431 rajveer 15948 
    if self.warehouseId is not None:
3064 chandransh 15949 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15950 
      oprot.writeI64(self.warehouseId)
15951 
      oprot.writeFieldEnd()
1886 ankur.sing 15952 
    oprot.writeFieldStop()
15953 
    oprot.writeStructEnd()
15954 
 
3431 rajveer 15955 
  def validate(self):
15956 
    return
15957 
 
15958 
 
1886 ankur.sing 15959 
  def __repr__(self):
15960 
    L = ['%s=%r' % (key, value)
15961 
      for key, value in self.__dict__.iteritems()]
15962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15963 
 
15964 
  def __eq__(self, other):
15965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15966 
 
15967 
  def __ne__(self, other):
15968 
    return not (self == other)
15969 
 
3064 chandransh 15970 
class getUndeliveredOrders_result:
1886 ankur.sing 15971 
  """
15972 
  Attributes:
15973 
   - success
15974 
  """
15975 
 
15976 
  thrift_spec = (
15977 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15978 
  )
15979 
 
15980 
  def __init__(self, success=None,):
15981 
    self.success = success
15982 
 
15983 
  def read(self, iprot):
15984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15986 
      return
15987 
    iprot.readStructBegin()
15988 
    while True:
15989 
      (fname, ftype, fid) = iprot.readFieldBegin()
15990 
      if ftype == TType.STOP:
15991 
        break
15992 
      if fid == 0:
15993 
        if ftype == TType.LIST:
15994 
          self.success = []
6188 rajveer 15995 
          (_etype396, _size393) = iprot.readListBegin()
15996 
          for _i397 in xrange(_size393):
15997 
            _elem398 = Order()
15998 
            _elem398.read(iprot)
15999 
            self.success.append(_elem398)
1886 ankur.sing 16000 
          iprot.readListEnd()
16001 
        else:
16002 
          iprot.skip(ftype)
16003 
      else:
16004 
        iprot.skip(ftype)
16005 
      iprot.readFieldEnd()
16006 
    iprot.readStructEnd()
16007 
 
16008 
  def write(self, oprot):
16009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16011 
      return
3064 chandransh 16012 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16013 
    if self.success is not None:
1886 ankur.sing 16014 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16015 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16016 
      for iter399 in self.success:
16017 
        iter399.write(oprot)
1886 ankur.sing 16018 
      oprot.writeListEnd()
16019 
      oprot.writeFieldEnd()
16020 
    oprot.writeFieldStop()
16021 
    oprot.writeStructEnd()
16022 
 
3431 rajveer 16023 
  def validate(self):
16024 
    return
16025 
 
16026 
 
1886 ankur.sing 16027 
  def __repr__(self):
16028 
    L = ['%s=%r' % (key, value)
16029 
      for key, value in self.__dict__.iteritems()]
16030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16031 
 
16032 
  def __eq__(self, other):
16033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16034 
 
16035 
  def __ne__(self, other):
16036 
    return not (self == other)
16037 
 
4783 phani.kuma 16038 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16039 
 
16040 
  thrift_spec = (
16041 
  )
16042 
 
16043 
  def read(self, iprot):
16044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16046 
      return
16047 
    iprot.readStructBegin()
16048 
    while True:
16049 
      (fname, ftype, fid) = iprot.readFieldBegin()
16050 
      if ftype == TType.STOP:
16051 
        break
16052 
      else:
16053 
        iprot.skip(ftype)
16054 
      iprot.readFieldEnd()
16055 
    iprot.readStructEnd()
16056 
 
16057 
  def write(self, oprot):
16058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16060 
      return
16061 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16062 
    oprot.writeFieldStop()
16063 
    oprot.writeStructEnd()
16064 
 
16065 
  def validate(self):
16066 
    return
16067 
 
16068 
 
16069 
  def __repr__(self):
16070 
    L = ['%s=%r' % (key, value)
16071 
      for key, value in self.__dict__.iteritems()]
16072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16073 
 
16074 
  def __eq__(self, other):
16075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16076 
 
16077 
  def __ne__(self, other):
16078 
    return not (self == other)
16079 
 
16080 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16081 
  """
16082 
  Attributes:
16083 
   - success
16084 
  """
16085 
 
16086 
  thrift_spec = (
16087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16088 
  )
16089 
 
16090 
  def __init__(self, success=None,):
16091 
    self.success = success
16092 
 
16093 
  def read(self, iprot):
16094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16096 
      return
16097 
    iprot.readStructBegin()
16098 
    while True:
16099 
      (fname, ftype, fid) = iprot.readFieldBegin()
16100 
      if ftype == TType.STOP:
16101 
        break
16102 
      if fid == 0:
16103 
        if ftype == TType.LIST:
16104 
          self.success = []
6188 rajveer 16105 
          (_etype403, _size400) = iprot.readListBegin()
16106 
          for _i404 in xrange(_size400):
16107 
            _elem405 = Order()
16108 
            _elem405.read(iprot)
16109 
            self.success.append(_elem405)
4783 phani.kuma 16110 
          iprot.readListEnd()
16111 
        else:
16112 
          iprot.skip(ftype)
16113 
      else:
16114 
        iprot.skip(ftype)
16115 
      iprot.readFieldEnd()
16116 
    iprot.readStructEnd()
16117 
 
16118 
  def write(self, oprot):
16119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16121 
      return
16122 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16123 
    if self.success is not None:
16124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16126 
      for iter406 in self.success:
16127 
        iter406.write(oprot)
4783 phani.kuma 16128 
      oprot.writeListEnd()
16129 
      oprot.writeFieldEnd()
16130 
    oprot.writeFieldStop()
16131 
    oprot.writeStructEnd()
16132 
 
16133 
  def validate(self):
16134 
    return
16135 
 
16136 
 
16137 
  def __repr__(self):
16138 
    L = ['%s=%r' % (key, value)
16139 
      for key, value in self.__dict__.iteritems()]
16140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16141 
 
16142 
  def __eq__(self, other):
16143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16144 
 
16145 
  def __ne__(self, other):
16146 
    return not (self == other)
16147 
 
2536 chandransh 16148 
class toggleDOAFlag_args:
16149 
  """
16150 
  Attributes:
16151 
   - orderId
16152 
  """
1886 ankur.sing 16153 
 
2536 chandransh 16154 
  thrift_spec = (
16155 
    None, # 0
16156 
    (1, TType.I64, 'orderId', None, None, ), # 1
16157 
  )
16158 
 
16159 
  def __init__(self, orderId=None,):
16160 
    self.orderId = orderId
16161 
 
16162 
  def read(self, iprot):
16163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16165 
      return
16166 
    iprot.readStructBegin()
16167 
    while True:
16168 
      (fname, ftype, fid) = iprot.readFieldBegin()
16169 
      if ftype == TType.STOP:
16170 
        break
16171 
      if fid == 1:
16172 
        if ftype == TType.I64:
16173 
          self.orderId = iprot.readI64();
16174 
        else:
16175 
          iprot.skip(ftype)
16176 
      else:
16177 
        iprot.skip(ftype)
16178 
      iprot.readFieldEnd()
16179 
    iprot.readStructEnd()
16180 
 
16181 
  def write(self, oprot):
16182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16184 
      return
16185 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16186 
    if self.orderId is not None:
2536 chandransh 16187 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16188 
      oprot.writeI64(self.orderId)
16189 
      oprot.writeFieldEnd()
16190 
    oprot.writeFieldStop()
16191 
    oprot.writeStructEnd()
16192 
 
3431 rajveer 16193 
  def validate(self):
16194 
    return
16195 
 
16196 
 
2536 chandransh 16197 
  def __repr__(self):
16198 
    L = ['%s=%r' % (key, value)
16199 
      for key, value in self.__dict__.iteritems()]
16200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16201 
 
16202 
  def __eq__(self, other):
16203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16204 
 
16205 
  def __ne__(self, other):
16206 
    return not (self == other)
16207 
 
16208 
class toggleDOAFlag_result:
16209 
  """
16210 
  Attributes:
16211 
   - success
16212 
   - ex
16213 
  """
16214 
 
16215 
  thrift_spec = (
16216 
    (0, TType.BOOL, 'success', None, None, ), # 0
16217 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16218 
  )
16219 
 
16220 
  def __init__(self, success=None, ex=None,):
16221 
    self.success = success
16222 
    self.ex = ex
16223 
 
16224 
  def read(self, iprot):
16225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16227 
      return
16228 
    iprot.readStructBegin()
16229 
    while True:
16230 
      (fname, ftype, fid) = iprot.readFieldBegin()
16231 
      if ftype == TType.STOP:
16232 
        break
16233 
      if fid == 0:
16234 
        if ftype == TType.BOOL:
16235 
          self.success = iprot.readBool();
16236 
        else:
16237 
          iprot.skip(ftype)
16238 
      elif fid == 1:
16239 
        if ftype == TType.STRUCT:
16240 
          self.ex = TransactionServiceException()
16241 
          self.ex.read(iprot)
16242 
        else:
16243 
          iprot.skip(ftype)
16244 
      else:
16245 
        iprot.skip(ftype)
16246 
      iprot.readFieldEnd()
16247 
    iprot.readStructEnd()
16248 
 
16249 
  def write(self, oprot):
16250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16252 
      return
16253 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16254 
    if self.success is not None:
2536 chandransh 16255 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16256 
      oprot.writeBool(self.success)
16257 
      oprot.writeFieldEnd()
3431 rajveer 16258 
    if self.ex is not None:
2536 chandransh 16259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16260 
      self.ex.write(oprot)
16261 
      oprot.writeFieldEnd()
16262 
    oprot.writeFieldStop()
16263 
    oprot.writeStructEnd()
16264 
 
3431 rajveer 16265 
  def validate(self):
16266 
    return
16267 
 
16268 
 
2536 chandransh 16269 
  def __repr__(self):
16270 
    L = ['%s=%r' % (key, value)
16271 
      for key, value in self.__dict__.iteritems()]
16272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16273 
 
16274 
  def __eq__(self, other):
16275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16276 
 
16277 
  def __ne__(self, other):
16278 
    return not (self == other)
16279 
 
4712 rajveer 16280 
class markOrderAsDelivered_args:
16281 
  """
16282 
  Attributes:
16283 
   - orderId
16284 
   - deliveryTimestamp
16285 
   - receiver
16286 
  """
16287 
 
16288 
  thrift_spec = None
16289 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16290 
    self.orderId = orderId
16291 
    self.deliveryTimestamp = deliveryTimestamp
16292 
    self.receiver = receiver
16293 
 
16294 
  def read(self, iprot):
16295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16297 
      return
16298 
    iprot.readStructBegin()
16299 
    while True:
16300 
      (fname, ftype, fid) = iprot.readFieldBegin()
16301 
      if ftype == TType.STOP:
16302 
        break
16303 
      if fid == 1:
16304 
        if ftype == TType.I64:
16305 
          self.orderId = iprot.readI64();
16306 
        else:
16307 
          iprot.skip(ftype)
16308 
      elif fid == 2:
16309 
        if ftype == TType.I64:
16310 
          self.deliveryTimestamp = iprot.readI64();
16311 
        else:
16312 
          iprot.skip(ftype)
16313 
      elif fid == -1:
16314 
        if ftype == TType.STRING:
16315 
          self.receiver = iprot.readString();
16316 
        else:
16317 
          iprot.skip(ftype)
16318 
      else:
16319 
        iprot.skip(ftype)
16320 
      iprot.readFieldEnd()
16321 
    iprot.readStructEnd()
16322 
 
16323 
  def write(self, oprot):
16324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16326 
      return
16327 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16328 
    if self.receiver is not None:
16329 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16330 
      oprot.writeString(self.receiver)
16331 
      oprot.writeFieldEnd()
16332 
    if self.orderId is not None:
16333 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16334 
      oprot.writeI64(self.orderId)
16335 
      oprot.writeFieldEnd()
16336 
    if self.deliveryTimestamp is not None:
16337 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16338 
      oprot.writeI64(self.deliveryTimestamp)
16339 
      oprot.writeFieldEnd()
16340 
    oprot.writeFieldStop()
16341 
    oprot.writeStructEnd()
16342 
 
16343 
  def validate(self):
16344 
    return
16345 
 
16346 
 
16347 
  def __repr__(self):
16348 
    L = ['%s=%r' % (key, value)
16349 
      for key, value in self.__dict__.iteritems()]
16350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16351 
 
16352 
  def __eq__(self, other):
16353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16354 
 
16355 
  def __ne__(self, other):
16356 
    return not (self == other)
16357 
 
16358 
class markOrderAsDelivered_result:
16359 
  """
16360 
  Attributes:
16361 
   - ex
16362 
  """
16363 
 
16364 
  thrift_spec = (
16365 
    None, # 0
16366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16367 
  )
16368 
 
16369 
  def __init__(self, ex=None,):
16370 
    self.ex = ex
16371 
 
16372 
  def read(self, iprot):
16373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16375 
      return
16376 
    iprot.readStructBegin()
16377 
    while True:
16378 
      (fname, ftype, fid) = iprot.readFieldBegin()
16379 
      if ftype == TType.STOP:
16380 
        break
16381 
      if fid == 1:
16382 
        if ftype == TType.STRUCT:
16383 
          self.ex = TransactionServiceException()
16384 
          self.ex.read(iprot)
16385 
        else:
16386 
          iprot.skip(ftype)
16387 
      else:
16388 
        iprot.skip(ftype)
16389 
      iprot.readFieldEnd()
16390 
    iprot.readStructEnd()
16391 
 
16392 
  def write(self, oprot):
16393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16395 
      return
16396 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16397 
    if self.ex is not None:
16398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16399 
      self.ex.write(oprot)
16400 
      oprot.writeFieldEnd()
16401 
    oprot.writeFieldStop()
16402 
    oprot.writeStructEnd()
16403 
 
16404 
  def validate(self):
16405 
    return
16406 
 
16407 
 
16408 
  def __repr__(self):
16409 
    L = ['%s=%r' % (key, value)
16410 
      for key, value in self.__dict__.iteritems()]
16411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16412 
 
16413 
  def __eq__(self, other):
16414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16415 
 
16416 
  def __ne__(self, other):
16417 
    return not (self == other)
16418 
 
5553 rajveer 16419 
class markOrderAsReceivedAtStore_args:
16420 
  """
16421 
  Attributes:
16422 
   - orderId
16423 
   - deliveryTimestamp
16424 
  """
16425 
 
16426 
  thrift_spec = (
16427 
    None, # 0
16428 
    (1, TType.I64, 'orderId', None, None, ), # 1
16429 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16430 
  )
16431 
 
16432 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16433 
    self.orderId = orderId
16434 
    self.deliveryTimestamp = deliveryTimestamp
16435 
 
16436 
  def read(self, iprot):
16437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16439 
      return
16440 
    iprot.readStructBegin()
16441 
    while True:
16442 
      (fname, ftype, fid) = iprot.readFieldBegin()
16443 
      if ftype == TType.STOP:
16444 
        break
16445 
      if fid == 1:
16446 
        if ftype == TType.I64:
16447 
          self.orderId = iprot.readI64();
16448 
        else:
16449 
          iprot.skip(ftype)
16450 
      elif fid == 2:
16451 
        if ftype == TType.I64:
16452 
          self.deliveryTimestamp = iprot.readI64();
16453 
        else:
16454 
          iprot.skip(ftype)
16455 
      else:
16456 
        iprot.skip(ftype)
16457 
      iprot.readFieldEnd()
16458 
    iprot.readStructEnd()
16459 
 
16460 
  def write(self, oprot):
16461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16463 
      return
16464 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16465 
    if self.orderId is not None:
16466 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16467 
      oprot.writeI64(self.orderId)
16468 
      oprot.writeFieldEnd()
16469 
    if self.deliveryTimestamp is not None:
16470 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16471 
      oprot.writeI64(self.deliveryTimestamp)
16472 
      oprot.writeFieldEnd()
16473 
    oprot.writeFieldStop()
16474 
    oprot.writeStructEnd()
16475 
 
16476 
  def validate(self):
16477 
    return
16478 
 
16479 
 
16480 
  def __repr__(self):
16481 
    L = ['%s=%r' % (key, value)
16482 
      for key, value in self.__dict__.iteritems()]
16483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16484 
 
16485 
  def __eq__(self, other):
16486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16487 
 
16488 
  def __ne__(self, other):
16489 
    return not (self == other)
16490 
 
16491 
class markOrderAsReceivedAtStore_result:
16492 
  """
16493 
  Attributes:
16494 
   - ex
16495 
  """
16496 
 
16497 
  thrift_spec = (
16498 
    None, # 0
16499 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16500 
  )
16501 
 
16502 
  def __init__(self, ex=None,):
16503 
    self.ex = ex
16504 
 
16505 
  def read(self, iprot):
16506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16508 
      return
16509 
    iprot.readStructBegin()
16510 
    while True:
16511 
      (fname, ftype, fid) = iprot.readFieldBegin()
16512 
      if ftype == TType.STOP:
16513 
        break
16514 
      if fid == 1:
16515 
        if ftype == TType.STRUCT:
16516 
          self.ex = TransactionServiceException()
16517 
          self.ex.read(iprot)
16518 
        else:
16519 
          iprot.skip(ftype)
16520 
      else:
16521 
        iprot.skip(ftype)
16522 
      iprot.readFieldEnd()
16523 
    iprot.readStructEnd()
16524 
 
16525 
  def write(self, oprot):
16526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16528 
      return
16529 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16530 
    if self.ex is not None:
16531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16532 
      self.ex.write(oprot)
16533 
      oprot.writeFieldEnd()
16534 
    oprot.writeFieldStop()
16535 
    oprot.writeStructEnd()
16536 
 
16537 
  def validate(self):
16538 
    return
16539 
 
16540 
 
16541 
  def __repr__(self):
16542 
    L = ['%s=%r' % (key, value)
16543 
      for key, value in self.__dict__.iteritems()]
16544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16545 
 
16546 
  def __eq__(self, other):
16547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16548 
 
16549 
  def __ne__(self, other):
16550 
    return not (self == other)
16551 
 
4454 rajveer 16552 
class markOrderDoaRequestReceived_args:
16553 
  """
16554 
  Attributes:
16555 
   - orderId
16556 
  """
16557 
 
16558 
  thrift_spec = (
16559 
    None, # 0
16560 
    (1, TType.I64, 'orderId', None, None, ), # 1
16561 
  )
16562 
 
16563 
  def __init__(self, orderId=None,):
16564 
    self.orderId = orderId
16565 
 
16566 
  def read(self, iprot):
16567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16569 
      return
16570 
    iprot.readStructBegin()
16571 
    while True:
16572 
      (fname, ftype, fid) = iprot.readFieldBegin()
16573 
      if ftype == TType.STOP:
16574 
        break
16575 
      if fid == 1:
16576 
        if ftype == TType.I64:
16577 
          self.orderId = iprot.readI64();
16578 
        else:
16579 
          iprot.skip(ftype)
16580 
      else:
16581 
        iprot.skip(ftype)
16582 
      iprot.readFieldEnd()
16583 
    iprot.readStructEnd()
16584 
 
16585 
  def write(self, oprot):
16586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16588 
      return
16589 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16590 
    if self.orderId is not None:
16591 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16592 
      oprot.writeI64(self.orderId)
16593 
      oprot.writeFieldEnd()
16594 
    oprot.writeFieldStop()
16595 
    oprot.writeStructEnd()
16596 
 
16597 
  def validate(self):
16598 
    return
16599 
 
16600 
 
16601 
  def __repr__(self):
16602 
    L = ['%s=%r' % (key, value)
16603 
      for key, value in self.__dict__.iteritems()]
16604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16605 
 
16606 
  def __eq__(self, other):
16607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16608 
 
16609 
  def __ne__(self, other):
16610 
    return not (self == other)
16611 
 
16612 
class markOrderDoaRequestReceived_result:
16613 
  """
16614 
  Attributes:
16615 
   - success
16616 
   - ex
16617 
  """
16618 
 
16619 
  thrift_spec = (
16620 
    (0, TType.BOOL, 'success', None, None, ), # 0
16621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16622 
  )
16623 
 
16624 
  def __init__(self, success=None, ex=None,):
16625 
    self.success = success
16626 
    self.ex = ex
16627 
 
16628 
  def read(self, iprot):
16629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16631 
      return
16632 
    iprot.readStructBegin()
16633 
    while True:
16634 
      (fname, ftype, fid) = iprot.readFieldBegin()
16635 
      if ftype == TType.STOP:
16636 
        break
16637 
      if fid == 0:
16638 
        if ftype == TType.BOOL:
16639 
          self.success = iprot.readBool();
16640 
        else:
16641 
          iprot.skip(ftype)
16642 
      elif fid == 1:
16643 
        if ftype == TType.STRUCT:
16644 
          self.ex = TransactionServiceException()
16645 
          self.ex.read(iprot)
16646 
        else:
16647 
          iprot.skip(ftype)
16648 
      else:
16649 
        iprot.skip(ftype)
16650 
      iprot.readFieldEnd()
16651 
    iprot.readStructEnd()
16652 
 
16653 
  def write(self, oprot):
16654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16656 
      return
16657 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16658 
    if self.success is not None:
16659 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16660 
      oprot.writeBool(self.success)
16661 
      oprot.writeFieldEnd()
16662 
    if self.ex is not None:
16663 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16664 
      self.ex.write(oprot)
16665 
      oprot.writeFieldEnd()
16666 
    oprot.writeFieldStop()
16667 
    oprot.writeStructEnd()
16668 
 
16669 
  def validate(self):
16670 
    return
16671 
 
16672 
 
16673 
  def __repr__(self):
16674 
    L = ['%s=%r' % (key, value)
16675 
      for key, value in self.__dict__.iteritems()]
16676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16677 
 
16678 
  def __eq__(self, other):
16679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16680 
 
16681 
  def __ne__(self, other):
16682 
    return not (self == other)
16683 
 
16684 
class markOrderDoaRequestAuthorized_args:
16685 
  """
16686 
  Attributes:
16687 
   - orderId
16688 
   - isAuthorized
16689 
  """
16690 
 
16691 
  thrift_spec = (
16692 
    None, # 0
16693 
    (1, TType.I64, 'orderId', None, None, ), # 1
16694 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16695 
  )
16696 
 
16697 
  def __init__(self, orderId=None, isAuthorized=None,):
16698 
    self.orderId = orderId
16699 
    self.isAuthorized = isAuthorized
16700 
 
16701 
  def read(self, iprot):
16702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16704 
      return
16705 
    iprot.readStructBegin()
16706 
    while True:
16707 
      (fname, ftype, fid) = iprot.readFieldBegin()
16708 
      if ftype == TType.STOP:
16709 
        break
16710 
      if fid == 1:
16711 
        if ftype == TType.I64:
16712 
          self.orderId = iprot.readI64();
16713 
        else:
16714 
          iprot.skip(ftype)
16715 
      elif fid == 2:
16716 
        if ftype == TType.BOOL:
16717 
          self.isAuthorized = iprot.readBool();
16718 
        else:
16719 
          iprot.skip(ftype)
16720 
      else:
16721 
        iprot.skip(ftype)
16722 
      iprot.readFieldEnd()
16723 
    iprot.readStructEnd()
16724 
 
16725 
  def write(self, oprot):
16726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16728 
      return
16729 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16730 
    if self.orderId is not None:
16731 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16732 
      oprot.writeI64(self.orderId)
16733 
      oprot.writeFieldEnd()
16734 
    if self.isAuthorized is not None:
16735 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16736 
      oprot.writeBool(self.isAuthorized)
16737 
      oprot.writeFieldEnd()
16738 
    oprot.writeFieldStop()
16739 
    oprot.writeStructEnd()
16740 
 
16741 
  def validate(self):
16742 
    return
16743 
 
16744 
 
16745 
  def __repr__(self):
16746 
    L = ['%s=%r' % (key, value)
16747 
      for key, value in self.__dict__.iteritems()]
16748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16749 
 
16750 
  def __eq__(self, other):
16751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16752 
 
16753 
  def __ne__(self, other):
16754 
    return not (self == other)
16755 
 
16756 
class markOrderDoaRequestAuthorized_result:
16757 
  """
16758 
  Attributes:
16759 
   - success
16760 
   - ex
16761 
  """
16762 
 
16763 
  thrift_spec = (
16764 
    (0, TType.BOOL, 'success', None, None, ), # 0
16765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16766 
  )
16767 
 
16768 
  def __init__(self, success=None, ex=None,):
16769 
    self.success = success
16770 
    self.ex = ex
16771 
 
16772 
  def read(self, iprot):
16773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16775 
      return
16776 
    iprot.readStructBegin()
16777 
    while True:
16778 
      (fname, ftype, fid) = iprot.readFieldBegin()
16779 
      if ftype == TType.STOP:
16780 
        break
16781 
      if fid == 0:
16782 
        if ftype == TType.BOOL:
16783 
          self.success = iprot.readBool();
16784 
        else:
16785 
          iprot.skip(ftype)
16786 
      elif fid == 1:
16787 
        if ftype == TType.STRUCT:
16788 
          self.ex = TransactionServiceException()
16789 
          self.ex.read(iprot)
16790 
        else:
16791 
          iprot.skip(ftype)
16792 
      else:
16793 
        iprot.skip(ftype)
16794 
      iprot.readFieldEnd()
16795 
    iprot.readStructEnd()
16796 
 
16797 
  def write(self, oprot):
16798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16800 
      return
16801 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16802 
    if self.success is not None:
16803 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16804 
      oprot.writeBool(self.success)
16805 
      oprot.writeFieldEnd()
16806 
    if self.ex is not None:
16807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16808 
      self.ex.write(oprot)
16809 
      oprot.writeFieldEnd()
16810 
    oprot.writeFieldStop()
16811 
    oprot.writeStructEnd()
16812 
 
16813 
  def validate(self):
16814 
    return
16815 
 
16816 
 
16817 
  def __repr__(self):
16818 
    L = ['%s=%r' % (key, value)
16819 
      for key, value in self.__dict__.iteritems()]
16820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16821 
 
16822 
  def __eq__(self, other):
16823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16824 
 
16825 
  def __ne__(self, other):
16826 
    return not (self == other)
16827 
 
4488 rajveer 16828 
class markOrderReturnRequestReceived_args:
16829 
  """
16830 
  Attributes:
16831 
   - orderId
16832 
  """
16833 
 
16834 
  thrift_spec = (
16835 
    None, # 0
16836 
    (1, TType.I64, 'orderId', None, None, ), # 1
16837 
  )
16838 
 
16839 
  def __init__(self, orderId=None,):
16840 
    self.orderId = orderId
16841 
 
16842 
  def read(self, iprot):
16843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16845 
      return
16846 
    iprot.readStructBegin()
16847 
    while True:
16848 
      (fname, ftype, fid) = iprot.readFieldBegin()
16849 
      if ftype == TType.STOP:
16850 
        break
16851 
      if fid == 1:
16852 
        if ftype == TType.I64:
16853 
          self.orderId = iprot.readI64();
16854 
        else:
16855 
          iprot.skip(ftype)
16856 
      else:
16857 
        iprot.skip(ftype)
16858 
      iprot.readFieldEnd()
16859 
    iprot.readStructEnd()
16860 
 
16861 
  def write(self, oprot):
16862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16864 
      return
16865 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16866 
    if self.orderId is not None:
16867 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16868 
      oprot.writeI64(self.orderId)
16869 
      oprot.writeFieldEnd()
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
16887 
 
16888 
class markOrderReturnRequestReceived_result:
16889 
  """
16890 
  Attributes:
16891 
   - success
16892 
   - ex
16893 
  """
16894 
 
16895 
  thrift_spec = (
16896 
    (0, TType.BOOL, 'success', None, None, ), # 0
16897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16898 
  )
16899 
 
16900 
  def __init__(self, success=None, ex=None,):
16901 
    self.success = success
16902 
    self.ex = ex
16903 
 
16904 
  def read(self, iprot):
16905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16907 
      return
16908 
    iprot.readStructBegin()
16909 
    while True:
16910 
      (fname, ftype, fid) = iprot.readFieldBegin()
16911 
      if ftype == TType.STOP:
16912 
        break
16913 
      if fid == 0:
16914 
        if ftype == TType.BOOL:
16915 
          self.success = iprot.readBool();
16916 
        else:
16917 
          iprot.skip(ftype)
16918 
      elif fid == 1:
16919 
        if ftype == TType.STRUCT:
16920 
          self.ex = TransactionServiceException()
16921 
          self.ex.read(iprot)
16922 
        else:
16923 
          iprot.skip(ftype)
16924 
      else:
16925 
        iprot.skip(ftype)
16926 
      iprot.readFieldEnd()
16927 
    iprot.readStructEnd()
16928 
 
16929 
  def write(self, oprot):
16930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16932 
      return
16933 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16934 
    if self.success is not None:
16935 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16936 
      oprot.writeBool(self.success)
16937 
      oprot.writeFieldEnd()
16938 
    if self.ex is not None:
16939 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16940 
      self.ex.write(oprot)
16941 
      oprot.writeFieldEnd()
16942 
    oprot.writeFieldStop()
16943 
    oprot.writeStructEnd()
16944 
 
16945 
  def validate(self):
16946 
    return
16947 
 
16948 
 
16949 
  def __repr__(self):
16950 
    L = ['%s=%r' % (key, value)
16951 
      for key, value in self.__dict__.iteritems()]
16952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16953 
 
16954 
  def __eq__(self, other):
16955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16956 
 
16957 
  def __ne__(self, other):
16958 
    return not (self == other)
16959 
 
16960 
class markOrderReturnRequestAuthorized_args:
16961 
  """
16962 
  Attributes:
16963 
   - orderId
16964 
   - isAuthorized
16965 
  """
16966 
 
16967 
  thrift_spec = (
16968 
    None, # 0
16969 
    (1, TType.I64, 'orderId', None, None, ), # 1
16970 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16971 
  )
16972 
 
16973 
  def __init__(self, orderId=None, isAuthorized=None,):
16974 
    self.orderId = orderId
16975 
    self.isAuthorized = isAuthorized
16976 
 
16977 
  def read(self, iprot):
16978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16980 
      return
16981 
    iprot.readStructBegin()
16982 
    while True:
16983 
      (fname, ftype, fid) = iprot.readFieldBegin()
16984 
      if ftype == TType.STOP:
16985 
        break
16986 
      if fid == 1:
16987 
        if ftype == TType.I64:
16988 
          self.orderId = iprot.readI64();
16989 
        else:
16990 
          iprot.skip(ftype)
16991 
      elif fid == 2:
16992 
        if ftype == TType.BOOL:
16993 
          self.isAuthorized = iprot.readBool();
16994 
        else:
16995 
          iprot.skip(ftype)
16996 
      else:
16997 
        iprot.skip(ftype)
16998 
      iprot.readFieldEnd()
16999 
    iprot.readStructEnd()
17000 
 
17001 
  def write(self, oprot):
17002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17004 
      return
17005 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17006 
    if self.orderId is not None:
17007 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17008 
      oprot.writeI64(self.orderId)
17009 
      oprot.writeFieldEnd()
17010 
    if self.isAuthorized is not None:
17011 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17012 
      oprot.writeBool(self.isAuthorized)
17013 
      oprot.writeFieldEnd()
17014 
    oprot.writeFieldStop()
17015 
    oprot.writeStructEnd()
17016 
 
17017 
  def validate(self):
17018 
    return
17019 
 
17020 
 
17021 
  def __repr__(self):
17022 
    L = ['%s=%r' % (key, value)
17023 
      for key, value in self.__dict__.iteritems()]
17024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17025 
 
17026 
  def __eq__(self, other):
17027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17028 
 
17029 
  def __ne__(self, other):
17030 
    return not (self == other)
17031 
 
17032 
class markOrderReturnRequestAuthorized_result:
17033 
  """
17034 
  Attributes:
17035 
   - success
17036 
   - ex
17037 
  """
17038 
 
17039 
  thrift_spec = (
17040 
    (0, TType.BOOL, 'success', None, None, ), # 0
17041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17042 
  )
17043 
 
17044 
  def __init__(self, success=None, ex=None,):
17045 
    self.success = success
17046 
    self.ex = ex
17047 
 
17048 
  def read(self, iprot):
17049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17051 
      return
17052 
    iprot.readStructBegin()
17053 
    while True:
17054 
      (fname, ftype, fid) = iprot.readFieldBegin()
17055 
      if ftype == TType.STOP:
17056 
        break
17057 
      if fid == 0:
17058 
        if ftype == TType.BOOL:
17059 
          self.success = iprot.readBool();
17060 
        else:
17061 
          iprot.skip(ftype)
17062 
      elif fid == 1:
17063 
        if ftype == TType.STRUCT:
17064 
          self.ex = TransactionServiceException()
17065 
          self.ex.read(iprot)
17066 
        else:
17067 
          iprot.skip(ftype)
17068 
      else:
17069 
        iprot.skip(ftype)
17070 
      iprot.readFieldEnd()
17071 
    iprot.readStructEnd()
17072 
 
17073 
  def write(self, oprot):
17074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17076 
      return
17077 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17078 
    if self.success is not None:
17079 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17080 
      oprot.writeBool(self.success)
17081 
      oprot.writeFieldEnd()
17082 
    if self.ex is not None:
17083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17084 
      self.ex.write(oprot)
17085 
      oprot.writeFieldEnd()
17086 
    oprot.writeFieldStop()
17087 
    oprot.writeStructEnd()
17088 
 
17089 
  def validate(self):
17090 
    return
17091 
 
17092 
 
17093 
  def __repr__(self):
17094 
    L = ['%s=%r' % (key, value)
17095 
      for key, value in self.__dict__.iteritems()]
17096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17097 
 
17098 
  def __eq__(self, other):
17099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17100 
 
17101 
  def __ne__(self, other):
17102 
    return not (self == other)
17103 
 
2536 chandransh 17104 
class requestPickupNumber_args:
17105 
  """
17106 
  Attributes:
17107 
   - orderId
4579 rajveer 17108 
   - providerId
2536 chandransh 17109 
  """
17110 
 
17111 
  thrift_spec = (
17112 
    None, # 0
17113 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17114 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17115 
  )
17116 
 
4579 rajveer 17117 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17118 
    self.orderId = orderId
4579 rajveer 17119 
    self.providerId = providerId
2536 chandransh 17120 
 
17121 
  def read(self, iprot):
17122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17124 
      return
17125 
    iprot.readStructBegin()
17126 
    while True:
17127 
      (fname, ftype, fid) = iprot.readFieldBegin()
17128 
      if ftype == TType.STOP:
17129 
        break
17130 
      if fid == 1:
17131 
        if ftype == TType.I64:
17132 
          self.orderId = iprot.readI64();
17133 
        else:
17134 
          iprot.skip(ftype)
4579 rajveer 17135 
      elif fid == 2:
17136 
        if ftype == TType.I64:
17137 
          self.providerId = iprot.readI64();
17138 
        else:
17139 
          iprot.skip(ftype)
2536 chandransh 17140 
      else:
17141 
        iprot.skip(ftype)
17142 
      iprot.readFieldEnd()
17143 
    iprot.readStructEnd()
17144 
 
17145 
  def write(self, oprot):
17146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17148 
      return
17149 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17150 
    if self.orderId is not None:
2536 chandransh 17151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17152 
      oprot.writeI64(self.orderId)
17153 
      oprot.writeFieldEnd()
4579 rajveer 17154 
    if self.providerId is not None:
17155 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17156 
      oprot.writeI64(self.providerId)
17157 
      oprot.writeFieldEnd()
2536 chandransh 17158 
    oprot.writeFieldStop()
17159 
    oprot.writeStructEnd()
17160 
 
3431 rajveer 17161 
  def validate(self):
17162 
    return
17163 
 
17164 
 
2536 chandransh 17165 
  def __repr__(self):
17166 
    L = ['%s=%r' % (key, value)
17167 
      for key, value in self.__dict__.iteritems()]
17168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17169 
 
17170 
  def __eq__(self, other):
17171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17172 
 
17173 
  def __ne__(self, other):
17174 
    return not (self == other)
17175 
 
17176 
class requestPickupNumber_result:
17177 
  """
17178 
  Attributes:
17179 
   - success
17180 
   - ex
17181 
  """
17182 
 
17183 
  thrift_spec = (
17184 
    (0, TType.BOOL, 'success', None, None, ), # 0
17185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17186 
  )
17187 
 
17188 
  def __init__(self, success=None, ex=None,):
17189 
    self.success = success
17190 
    self.ex = ex
17191 
 
17192 
  def read(self, iprot):
17193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17195 
      return
17196 
    iprot.readStructBegin()
17197 
    while True:
17198 
      (fname, ftype, fid) = iprot.readFieldBegin()
17199 
      if ftype == TType.STOP:
17200 
        break
17201 
      if fid == 0:
17202 
        if ftype == TType.BOOL:
17203 
          self.success = iprot.readBool();
17204 
        else:
17205 
          iprot.skip(ftype)
17206 
      elif fid == 1:
17207 
        if ftype == TType.STRUCT:
17208 
          self.ex = TransactionServiceException()
17209 
          self.ex.read(iprot)
17210 
        else:
17211 
          iprot.skip(ftype)
17212 
      else:
17213 
        iprot.skip(ftype)
17214 
      iprot.readFieldEnd()
17215 
    iprot.readStructEnd()
17216 
 
17217 
  def write(self, oprot):
17218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17220 
      return
17221 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17222 
    if self.success is not None:
2536 chandransh 17223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17224 
      oprot.writeBool(self.success)
17225 
      oprot.writeFieldEnd()
3431 rajveer 17226 
    if self.ex is not None:
2536 chandransh 17227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17228 
      self.ex.write(oprot)
17229 
      oprot.writeFieldEnd()
17230 
    oprot.writeFieldStop()
17231 
    oprot.writeStructEnd()
17232 
 
3431 rajveer 17233 
  def validate(self):
17234 
    return
17235 
 
17236 
 
2536 chandransh 17237 
  def __repr__(self):
17238 
    L = ['%s=%r' % (key, value)
17239 
      for key, value in self.__dict__.iteritems()]
17240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17241 
 
17242 
  def __eq__(self, other):
17243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17244 
 
17245 
  def __ne__(self, other):
17246 
    return not (self == other)
17247 
 
17248 
class authorizePickup_args:
17249 
  """
17250 
  Attributes:
17251 
   - orderId
17252 
   - pickupNumber
4602 rajveer 17253 
   - providerId
2536 chandransh 17254 
  """
17255 
 
17256 
  thrift_spec = (
17257 
    None, # 0
17258 
    (1, TType.I64, 'orderId', None, None, ), # 1
17259 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17260 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17261 
  )
17262 
 
4602 rajveer 17263 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17264 
    self.orderId = orderId
17265 
    self.pickupNumber = pickupNumber
4602 rajveer 17266 
    self.providerId = providerId
2536 chandransh 17267 
 
17268 
  def read(self, iprot):
17269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17271 
      return
17272 
    iprot.readStructBegin()
17273 
    while True:
17274 
      (fname, ftype, fid) = iprot.readFieldBegin()
17275 
      if ftype == TType.STOP:
17276 
        break
17277 
      if fid == 1:
17278 
        if ftype == TType.I64:
17279 
          self.orderId = iprot.readI64();
17280 
        else:
17281 
          iprot.skip(ftype)
17282 
      elif fid == 2:
17283 
        if ftype == TType.STRING:
17284 
          self.pickupNumber = iprot.readString();
17285 
        else:
17286 
          iprot.skip(ftype)
4602 rajveer 17287 
      elif fid == 3:
17288 
        if ftype == TType.I64:
17289 
          self.providerId = iprot.readI64();
17290 
        else:
17291 
          iprot.skip(ftype)
2536 chandransh 17292 
      else:
17293 
        iprot.skip(ftype)
17294 
      iprot.readFieldEnd()
17295 
    iprot.readStructEnd()
17296 
 
17297 
  def write(self, oprot):
17298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17300 
      return
17301 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17302 
    if self.orderId is not None:
2536 chandransh 17303 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17304 
      oprot.writeI64(self.orderId)
17305 
      oprot.writeFieldEnd()
3431 rajveer 17306 
    if self.pickupNumber is not None:
2536 chandransh 17307 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17308 
      oprot.writeString(self.pickupNumber)
17309 
      oprot.writeFieldEnd()
4602 rajveer 17310 
    if self.providerId is not None:
17311 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17312 
      oprot.writeI64(self.providerId)
17313 
      oprot.writeFieldEnd()
2536 chandransh 17314 
    oprot.writeFieldStop()
17315 
    oprot.writeStructEnd()
17316 
 
3431 rajveer 17317 
  def validate(self):
17318 
    return
17319 
 
17320 
 
2536 chandransh 17321 
  def __repr__(self):
17322 
    L = ['%s=%r' % (key, value)
17323 
      for key, value in self.__dict__.iteritems()]
17324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17325 
 
17326 
  def __eq__(self, other):
17327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17328 
 
17329 
  def __ne__(self, other):
17330 
    return not (self == other)
17331 
 
17332 
class authorizePickup_result:
17333 
  """
17334 
  Attributes:
17335 
   - success
17336 
   - ex
17337 
  """
17338 
 
17339 
  thrift_spec = (
17340 
    (0, TType.BOOL, 'success', None, None, ), # 0
17341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17342 
  )
17343 
 
17344 
  def __init__(self, success=None, ex=None,):
17345 
    self.success = success
17346 
    self.ex = ex
17347 
 
17348 
  def read(self, iprot):
17349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17351 
      return
17352 
    iprot.readStructBegin()
17353 
    while True:
17354 
      (fname, ftype, fid) = iprot.readFieldBegin()
17355 
      if ftype == TType.STOP:
17356 
        break
17357 
      if fid == 0:
17358 
        if ftype == TType.BOOL:
17359 
          self.success = iprot.readBool();
17360 
        else:
17361 
          iprot.skip(ftype)
17362 
      elif fid == 1:
17363 
        if ftype == TType.STRUCT:
17364 
          self.ex = TransactionServiceException()
17365 
          self.ex.read(iprot)
17366 
        else:
17367 
          iprot.skip(ftype)
17368 
      else:
17369 
        iprot.skip(ftype)
17370 
      iprot.readFieldEnd()
17371 
    iprot.readStructEnd()
17372 
 
17373 
  def write(self, oprot):
17374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17376 
      return
17377 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17378 
    if self.success is not None:
2536 chandransh 17379 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17380 
      oprot.writeBool(self.success)
17381 
      oprot.writeFieldEnd()
3431 rajveer 17382 
    if self.ex is not None:
2536 chandransh 17383 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17384 
      self.ex.write(oprot)
17385 
      oprot.writeFieldEnd()
17386 
    oprot.writeFieldStop()
17387 
    oprot.writeStructEnd()
17388 
 
3431 rajveer 17389 
  def validate(self):
17390 
    return
17391 
 
17392 
 
2536 chandransh 17393 
  def __repr__(self):
17394 
    L = ['%s=%r' % (key, value)
17395 
      for key, value in self.__dict__.iteritems()]
17396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17397 
 
17398 
  def __eq__(self, other):
17399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17400 
 
17401 
  def __ne__(self, other):
17402 
    return not (self == other)
17403 
 
2764 chandransh 17404 
class markDoasAsPickedUp_args:
17405 
  """
17406 
  Attributes:
17407 
   - providerId
17408 
   - pickupDetails
17409 
  """
17410 
 
17411 
  thrift_spec = (
17412 
    None, # 0
17413 
    (1, TType.I64, 'providerId', None, None, ), # 1
17414 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17415 
  )
17416 
 
17417 
  def __init__(self, providerId=None, pickupDetails=None,):
17418 
    self.providerId = providerId
17419 
    self.pickupDetails = pickupDetails
17420 
 
17421 
  def read(self, iprot):
17422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17424 
      return
17425 
    iprot.readStructBegin()
17426 
    while True:
17427 
      (fname, ftype, fid) = iprot.readFieldBegin()
17428 
      if ftype == TType.STOP:
17429 
        break
17430 
      if fid == 1:
17431 
        if ftype == TType.I64:
17432 
          self.providerId = iprot.readI64();
17433 
        else:
17434 
          iprot.skip(ftype)
17435 
      elif fid == 2:
17436 
        if ftype == TType.MAP:
17437 
          self.pickupDetails = {}
6188 rajveer 17438 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17439 
          for _i411 in xrange(_size407):
17440 
            _key412 = iprot.readString();
17441 
            _val413 = iprot.readString();
17442 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17443 
          iprot.readMapEnd()
17444 
        else:
17445 
          iprot.skip(ftype)
17446 
      else:
17447 
        iprot.skip(ftype)
17448 
      iprot.readFieldEnd()
17449 
    iprot.readStructEnd()
17450 
 
17451 
  def write(self, oprot):
17452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17454 
      return
17455 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17456 
    if self.providerId is not None:
2764 chandransh 17457 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17458 
      oprot.writeI64(self.providerId)
17459 
      oprot.writeFieldEnd()
3431 rajveer 17460 
    if self.pickupDetails is not None:
2764 chandransh 17461 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17462 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17463 
      for kiter414,viter415 in self.pickupDetails.items():
17464 
        oprot.writeString(kiter414)
17465 
        oprot.writeString(viter415)
2764 chandransh 17466 
      oprot.writeMapEnd()
17467 
      oprot.writeFieldEnd()
17468 
    oprot.writeFieldStop()
17469 
    oprot.writeStructEnd()
17470 
 
3431 rajveer 17471 
  def validate(self):
17472 
    return
17473 
 
17474 
 
2764 chandransh 17475 
  def __repr__(self):
17476 
    L = ['%s=%r' % (key, value)
17477 
      for key, value in self.__dict__.iteritems()]
17478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17479 
 
17480 
  def __eq__(self, other):
17481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17482 
 
17483 
  def __ne__(self, other):
17484 
    return not (self == other)
17485 
 
17486 
class markDoasAsPickedUp_result:
4910 phani.kuma 17487 
 
17488 
  thrift_spec = (
17489 
  )
17490 
 
17491 
  def read(self, iprot):
17492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17494 
      return
17495 
    iprot.readStructBegin()
17496 
    while True:
17497 
      (fname, ftype, fid) = iprot.readFieldBegin()
17498 
      if ftype == TType.STOP:
17499 
        break
17500 
      else:
17501 
        iprot.skip(ftype)
17502 
      iprot.readFieldEnd()
17503 
    iprot.readStructEnd()
17504 
 
17505 
  def write(self, oprot):
17506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17508 
      return
17509 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17510 
    oprot.writeFieldStop()
17511 
    oprot.writeStructEnd()
17512 
 
17513 
  def validate(self):
17514 
    return
17515 
 
17516 
 
17517 
  def __repr__(self):
17518 
    L = ['%s=%r' % (key, value)
17519 
      for key, value in self.__dict__.iteritems()]
17520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17521 
 
17522 
  def __eq__(self, other):
17523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17524 
 
17525 
  def __ne__(self, other):
17526 
    return not (self == other)
17527 
 
17528 
class getDoasNotPickedUp_args:
2764 chandransh 17529 
  """
17530 
  Attributes:
4910 phani.kuma 17531 
   - providerId
17532 
  """
17533 
 
17534 
  thrift_spec = (
17535 
    None, # 0
17536 
    (1, TType.I64, 'providerId', None, None, ), # 1
17537 
  )
17538 
 
17539 
  def __init__(self, providerId=None,):
17540 
    self.providerId = providerId
17541 
 
17542 
  def read(self, iprot):
17543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17545 
      return
17546 
    iprot.readStructBegin()
17547 
    while True:
17548 
      (fname, ftype, fid) = iprot.readFieldBegin()
17549 
      if ftype == TType.STOP:
17550 
        break
17551 
      if fid == 1:
17552 
        if ftype == TType.I64:
17553 
          self.providerId = iprot.readI64();
17554 
        else:
17555 
          iprot.skip(ftype)
17556 
      else:
17557 
        iprot.skip(ftype)
17558 
      iprot.readFieldEnd()
17559 
    iprot.readStructEnd()
17560 
 
17561 
  def write(self, oprot):
17562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17564 
      return
17565 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17566 
    if self.providerId is not None:
17567 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17568 
      oprot.writeI64(self.providerId)
17569 
      oprot.writeFieldEnd()
17570 
    oprot.writeFieldStop()
17571 
    oprot.writeStructEnd()
17572 
 
17573 
  def validate(self):
17574 
    return
17575 
 
17576 
 
17577 
  def __repr__(self):
17578 
    L = ['%s=%r' % (key, value)
17579 
      for key, value in self.__dict__.iteritems()]
17580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17581 
 
17582 
  def __eq__(self, other):
17583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17584 
 
17585 
  def __ne__(self, other):
17586 
    return not (self == other)
17587 
 
17588 
class getDoasNotPickedUp_result:
17589 
  """
17590 
  Attributes:
2764 chandransh 17591 
   - success
17592 
  """
17593 
 
17594 
  thrift_spec = (
17595 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17596 
  )
17597 
 
17598 
  def __init__(self, success=None,):
17599 
    self.success = success
17600 
 
17601 
  def read(self, iprot):
17602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17604 
      return
17605 
    iprot.readStructBegin()
17606 
    while True:
17607 
      (fname, ftype, fid) = iprot.readFieldBegin()
17608 
      if ftype == TType.STOP:
17609 
        break
17610 
      if fid == 0:
17611 
        if ftype == TType.LIST:
17612 
          self.success = []
6188 rajveer 17613 
          (_etype419, _size416) = iprot.readListBegin()
17614 
          for _i420 in xrange(_size416):
17615 
            _elem421 = Order()
17616 
            _elem421.read(iprot)
17617 
            self.success.append(_elem421)
2764 chandransh 17618 
          iprot.readListEnd()
17619 
        else:
17620 
          iprot.skip(ftype)
17621 
      else:
17622 
        iprot.skip(ftype)
17623 
      iprot.readFieldEnd()
17624 
    iprot.readStructEnd()
17625 
 
17626 
  def write(self, oprot):
17627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17629 
      return
4910 phani.kuma 17630 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17631 
    if self.success is not None:
2764 chandransh 17632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17634 
      for iter422 in self.success:
17635 
        iter422.write(oprot)
2764 chandransh 17636 
      oprot.writeListEnd()
17637 
      oprot.writeFieldEnd()
17638 
    oprot.writeFieldStop()
17639 
    oprot.writeStructEnd()
17640 
 
3431 rajveer 17641 
  def validate(self):
17642 
    return
17643 
 
17644 
 
2764 chandransh 17645 
  def __repr__(self):
17646 
    L = ['%s=%r' % (key, value)
17647 
      for key, value in self.__dict__.iteritems()]
17648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17649 
 
17650 
  def __eq__(self, other):
17651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17652 
 
17653 
  def __ne__(self, other):
17654 
    return not (self == other)
17655 
 
4741 phani.kuma 17656 
class markReturnOrdersAsPickedUp_args:
17657 
  """
17658 
  Attributes:
17659 
   - providerId
17660 
   - pickupDetails
17661 
  """
17662 
 
17663 
  thrift_spec = (
17664 
    None, # 0
17665 
    (1, TType.I64, 'providerId', None, None, ), # 1
17666 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17667 
  )
17668 
 
17669 
  def __init__(self, providerId=None, pickupDetails=None,):
17670 
    self.providerId = providerId
17671 
    self.pickupDetails = pickupDetails
17672 
 
17673 
  def read(self, iprot):
17674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17676 
      return
17677 
    iprot.readStructBegin()
17678 
    while True:
17679 
      (fname, ftype, fid) = iprot.readFieldBegin()
17680 
      if ftype == TType.STOP:
17681 
        break
17682 
      if fid == 1:
17683 
        if ftype == TType.I64:
17684 
          self.providerId = iprot.readI64();
17685 
        else:
17686 
          iprot.skip(ftype)
17687 
      elif fid == 2:
17688 
        if ftype == TType.MAP:
17689 
          self.pickupDetails = {}
6188 rajveer 17690 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17691 
          for _i427 in xrange(_size423):
17692 
            _key428 = iprot.readString();
17693 
            _val429 = iprot.readString();
17694 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17695 
          iprot.readMapEnd()
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      else:
17699 
        iprot.skip(ftype)
17700 
      iprot.readFieldEnd()
17701 
    iprot.readStructEnd()
17702 
 
17703 
  def write(self, oprot):
17704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17706 
      return
17707 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17708 
    if self.providerId is not None:
17709 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17710 
      oprot.writeI64(self.providerId)
17711 
      oprot.writeFieldEnd()
17712 
    if self.pickupDetails is not None:
17713 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17714 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17715 
      for kiter430,viter431 in self.pickupDetails.items():
17716 
        oprot.writeString(kiter430)
17717 
        oprot.writeString(viter431)
4741 phani.kuma 17718 
      oprot.writeMapEnd()
17719 
      oprot.writeFieldEnd()
17720 
    oprot.writeFieldStop()
17721 
    oprot.writeStructEnd()
17722 
 
17723 
  def validate(self):
17724 
    return
17725 
 
17726 
 
17727 
  def __repr__(self):
17728 
    L = ['%s=%r' % (key, value)
17729 
      for key, value in self.__dict__.iteritems()]
17730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17731 
 
17732 
  def __eq__(self, other):
17733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17734 
 
17735 
  def __ne__(self, other):
17736 
    return not (self == other)
17737 
 
17738 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17739 
 
17740 
  thrift_spec = (
17741 
  )
17742 
 
17743 
  def read(self, iprot):
17744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17746 
      return
17747 
    iprot.readStructBegin()
17748 
    while True:
17749 
      (fname, ftype, fid) = iprot.readFieldBegin()
17750 
      if ftype == TType.STOP:
17751 
        break
17752 
      else:
17753 
        iprot.skip(ftype)
17754 
      iprot.readFieldEnd()
17755 
    iprot.readStructEnd()
17756 
 
17757 
  def write(self, oprot):
17758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17760 
      return
17761 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17762 
    oprot.writeFieldStop()
17763 
    oprot.writeStructEnd()
17764 
 
17765 
  def validate(self):
17766 
    return
17767 
 
17768 
 
17769 
  def __repr__(self):
17770 
    L = ['%s=%r' % (key, value)
17771 
      for key, value in self.__dict__.iteritems()]
17772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17773 
 
17774 
  def __eq__(self, other):
17775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17776 
 
17777 
  def __ne__(self, other):
17778 
    return not (self == other)
17779 
 
17780 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17781 
  """
17782 
  Attributes:
4910 phani.kuma 17783 
   - providerId
17784 
  """
17785 
 
17786 
  thrift_spec = (
17787 
    None, # 0
17788 
    (1, TType.I64, 'providerId', None, None, ), # 1
17789 
  )
17790 
 
17791 
  def __init__(self, providerId=None,):
17792 
    self.providerId = providerId
17793 
 
17794 
  def read(self, iprot):
17795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17797 
      return
17798 
    iprot.readStructBegin()
17799 
    while True:
17800 
      (fname, ftype, fid) = iprot.readFieldBegin()
17801 
      if ftype == TType.STOP:
17802 
        break
17803 
      if fid == 1:
17804 
        if ftype == TType.I64:
17805 
          self.providerId = iprot.readI64();
17806 
        else:
17807 
          iprot.skip(ftype)
17808 
      else:
17809 
        iprot.skip(ftype)
17810 
      iprot.readFieldEnd()
17811 
    iprot.readStructEnd()
17812 
 
17813 
  def write(self, oprot):
17814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17816 
      return
17817 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17818 
    if self.providerId is not None:
17819 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17820 
      oprot.writeI64(self.providerId)
17821 
      oprot.writeFieldEnd()
17822 
    oprot.writeFieldStop()
17823 
    oprot.writeStructEnd()
17824 
 
17825 
  def validate(self):
17826 
    return
17827 
 
17828 
 
17829 
  def __repr__(self):
17830 
    L = ['%s=%r' % (key, value)
17831 
      for key, value in self.__dict__.iteritems()]
17832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17833 
 
17834 
  def __eq__(self, other):
17835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17836 
 
17837 
  def __ne__(self, other):
17838 
    return not (self == other)
17839 
 
17840 
class getReturnOrdersNotPickedUp_result:
17841 
  """
17842 
  Attributes:
4741 phani.kuma 17843 
   - success
17844 
  """
17845 
 
17846 
  thrift_spec = (
17847 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17848 
  )
17849 
 
17850 
  def __init__(self, success=None,):
17851 
    self.success = success
17852 
 
17853 
  def read(self, iprot):
17854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17856 
      return
17857 
    iprot.readStructBegin()
17858 
    while True:
17859 
      (fname, ftype, fid) = iprot.readFieldBegin()
17860 
      if ftype == TType.STOP:
17861 
        break
17862 
      if fid == 0:
17863 
        if ftype == TType.LIST:
17864 
          self.success = []
6188 rajveer 17865 
          (_etype435, _size432) = iprot.readListBegin()
17866 
          for _i436 in xrange(_size432):
17867 
            _elem437 = Order()
17868 
            _elem437.read(iprot)
17869 
            self.success.append(_elem437)
4741 phani.kuma 17870 
          iprot.readListEnd()
17871 
        else:
17872 
          iprot.skip(ftype)
17873 
      else:
17874 
        iprot.skip(ftype)
17875 
      iprot.readFieldEnd()
17876 
    iprot.readStructEnd()
17877 
 
17878 
  def write(self, oprot):
17879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17881 
      return
4910 phani.kuma 17882 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17883 
    if self.success is not None:
17884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17886 
      for iter438 in self.success:
17887 
        iter438.write(oprot)
4741 phani.kuma 17888 
      oprot.writeListEnd()
17889 
      oprot.writeFieldEnd()
17890 
    oprot.writeFieldStop()
17891 
    oprot.writeStructEnd()
17892 
 
17893 
  def validate(self):
17894 
    return
17895 
 
17896 
 
17897 
  def __repr__(self):
17898 
    L = ['%s=%r' % (key, value)
17899 
      for key, value in self.__dict__.iteritems()]
17900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17901 
 
17902 
  def __eq__(self, other):
17903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17904 
 
17905 
  def __ne__(self, other):
17906 
    return not (self == other)
17907 
 
2616 chandransh 17908 
class receiveReturn_args:
2591 chandransh 17909 
  """
17910 
  Attributes:
17911 
   - orderId
4479 rajveer 17912 
   - receiveCondition
2591 chandransh 17913 
  """
2536 chandransh 17914 
 
2591 chandransh 17915 
  thrift_spec = (
17916 
    None, # 0
17917 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17918 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17919 
  )
17920 
 
4479 rajveer 17921 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17922 
    self.orderId = orderId
4479 rajveer 17923 
    self.receiveCondition = receiveCondition
2591 chandransh 17924 
 
17925 
  def read(self, iprot):
17926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17928 
      return
17929 
    iprot.readStructBegin()
17930 
    while True:
17931 
      (fname, ftype, fid) = iprot.readFieldBegin()
17932 
      if ftype == TType.STOP:
17933 
        break
17934 
      if fid == 1:
17935 
        if ftype == TType.I64:
17936 
          self.orderId = iprot.readI64();
17937 
        else:
17938 
          iprot.skip(ftype)
4479 rajveer 17939 
      elif fid == 2:
17940 
        if ftype == TType.I64:
17941 
          self.receiveCondition = iprot.readI64();
17942 
        else:
17943 
          iprot.skip(ftype)
2591 chandransh 17944 
      else:
17945 
        iprot.skip(ftype)
17946 
      iprot.readFieldEnd()
17947 
    iprot.readStructEnd()
17948 
 
17949 
  def write(self, oprot):
17950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17952 
      return
2616 chandransh 17953 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17954 
    if self.orderId is not None:
2591 chandransh 17955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17956 
      oprot.writeI64(self.orderId)
17957 
      oprot.writeFieldEnd()
4479 rajveer 17958 
    if self.receiveCondition is not None:
17959 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17960 
      oprot.writeI64(self.receiveCondition)
17961 
      oprot.writeFieldEnd()
2591 chandransh 17962 
    oprot.writeFieldStop()
17963 
    oprot.writeStructEnd()
17964 
 
3431 rajveer 17965 
  def validate(self):
17966 
    return
17967 
 
17968 
 
2591 chandransh 17969 
  def __repr__(self):
17970 
    L = ['%s=%r' % (key, value)
17971 
      for key, value in self.__dict__.iteritems()]
17972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17973 
 
17974 
  def __eq__(self, other):
17975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17976 
 
17977 
  def __ne__(self, other):
17978 
    return not (self == other)
17979 
 
2616 chandransh 17980 
class receiveReturn_result:
2591 chandransh 17981 
  """
17982 
  Attributes:
17983 
   - success
17984 
   - ex
17985 
  """
17986 
 
17987 
  thrift_spec = (
17988 
    (0, TType.BOOL, 'success', None, None, ), # 0
17989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17990 
  )
17991 
 
17992 
  def __init__(self, success=None, ex=None,):
17993 
    self.success = success
17994 
    self.ex = ex
17995 
 
17996 
  def read(self, iprot):
17997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17999 
      return
18000 
    iprot.readStructBegin()
18001 
    while True:
18002 
      (fname, ftype, fid) = iprot.readFieldBegin()
18003 
      if ftype == TType.STOP:
18004 
        break
18005 
      if fid == 0:
18006 
        if ftype == TType.BOOL:
18007 
          self.success = iprot.readBool();
18008 
        else:
18009 
          iprot.skip(ftype)
18010 
      elif fid == 1:
18011 
        if ftype == TType.STRUCT:
18012 
          self.ex = TransactionServiceException()
18013 
          self.ex.read(iprot)
18014 
        else:
18015 
          iprot.skip(ftype)
18016 
      else:
18017 
        iprot.skip(ftype)
18018 
      iprot.readFieldEnd()
18019 
    iprot.readStructEnd()
18020 
 
18021 
  def write(self, oprot):
18022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18024 
      return
2616 chandransh 18025 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18026 
    if self.success is not None:
2591 chandransh 18027 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18028 
      oprot.writeBool(self.success)
18029 
      oprot.writeFieldEnd()
3431 rajveer 18030 
    if self.ex is not None:
2591 chandransh 18031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18032 
      self.ex.write(oprot)
18033 
      oprot.writeFieldEnd()
18034 
    oprot.writeFieldStop()
18035 
    oprot.writeStructEnd()
18036 
 
3431 rajveer 18037 
  def validate(self):
18038 
    return
18039 
 
18040 
 
2591 chandransh 18041 
  def __repr__(self):
18042 
    L = ['%s=%r' % (key, value)
18043 
      for key, value in self.__dict__.iteritems()]
18044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18045 
 
18046 
  def __eq__(self, other):
18047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18048 
 
18049 
  def __ne__(self, other):
18050 
    return not (self == other)
18051 
 
18052 
class validateDoa_args:
18053 
  """
18054 
  Attributes:
18055 
   - orderId
18056 
   - isValid
18057 
  """
18058 
 
18059 
  thrift_spec = (
18060 
    None, # 0
18061 
    (1, TType.I64, 'orderId', None, None, ), # 1
18062 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18063 
  )
18064 
 
18065 
  def __init__(self, orderId=None, isValid=None,):
18066 
    self.orderId = orderId
18067 
    self.isValid = isValid
18068 
 
18069 
  def read(self, iprot):
18070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18072 
      return
18073 
    iprot.readStructBegin()
18074 
    while True:
18075 
      (fname, ftype, fid) = iprot.readFieldBegin()
18076 
      if ftype == TType.STOP:
18077 
        break
18078 
      if fid == 1:
18079 
        if ftype == TType.I64:
18080 
          self.orderId = iprot.readI64();
18081 
        else:
18082 
          iprot.skip(ftype)
18083 
      elif fid == 2:
18084 
        if ftype == TType.BOOL:
18085 
          self.isValid = iprot.readBool();
18086 
        else:
18087 
          iprot.skip(ftype)
18088 
      else:
18089 
        iprot.skip(ftype)
18090 
      iprot.readFieldEnd()
18091 
    iprot.readStructEnd()
18092 
 
18093 
  def write(self, oprot):
18094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18096 
      return
18097 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18098 
    if self.orderId is not None:
2591 chandransh 18099 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18100 
      oprot.writeI64(self.orderId)
18101 
      oprot.writeFieldEnd()
3431 rajveer 18102 
    if self.isValid is not None:
2591 chandransh 18103 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18104 
      oprot.writeBool(self.isValid)
18105 
      oprot.writeFieldEnd()
18106 
    oprot.writeFieldStop()
18107 
    oprot.writeStructEnd()
18108 
 
3431 rajveer 18109 
  def validate(self):
18110 
    return
18111 
 
18112 
 
2591 chandransh 18113 
  def __repr__(self):
18114 
    L = ['%s=%r' % (key, value)
18115 
      for key, value in self.__dict__.iteritems()]
18116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18117 
 
18118 
  def __eq__(self, other):
18119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18120 
 
18121 
  def __ne__(self, other):
18122 
    return not (self == other)
18123 
 
18124 
class validateDoa_result:
18125 
  """
18126 
  Attributes:
18127 
   - success
18128 
   - ex
18129 
  """
18130 
 
18131 
  thrift_spec = (
18132 
    (0, TType.BOOL, 'success', None, None, ), # 0
18133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18134 
  )
18135 
 
18136 
  def __init__(self, success=None, ex=None,):
18137 
    self.success = success
18138 
    self.ex = ex
18139 
 
18140 
  def read(self, iprot):
18141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18143 
      return
18144 
    iprot.readStructBegin()
18145 
    while True:
18146 
      (fname, ftype, fid) = iprot.readFieldBegin()
18147 
      if ftype == TType.STOP:
18148 
        break
18149 
      if fid == 0:
18150 
        if ftype == TType.BOOL:
18151 
          self.success = iprot.readBool();
18152 
        else:
18153 
          iprot.skip(ftype)
18154 
      elif fid == 1:
18155 
        if ftype == TType.STRUCT:
18156 
          self.ex = TransactionServiceException()
18157 
          self.ex.read(iprot)
18158 
        else:
18159 
          iprot.skip(ftype)
18160 
      else:
18161 
        iprot.skip(ftype)
18162 
      iprot.readFieldEnd()
18163 
    iprot.readStructEnd()
18164 
 
18165 
  def write(self, oprot):
18166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18168 
      return
18169 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18170 
    if self.success is not None:
2591 chandransh 18171 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18172 
      oprot.writeBool(self.success)
18173 
      oprot.writeFieldEnd()
3431 rajveer 18174 
    if self.ex is not None:
2591 chandransh 18175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18176 
      self.ex.write(oprot)
18177 
      oprot.writeFieldEnd()
18178 
    oprot.writeFieldStop()
18179 
    oprot.writeStructEnd()
18180 
 
3431 rajveer 18181 
  def validate(self):
18182 
    return
18183 
 
18184 
 
2591 chandransh 18185 
  def __repr__(self):
18186 
    L = ['%s=%r' % (key, value)
18187 
      for key, value in self.__dict__.iteritems()]
18188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18189 
 
18190 
  def __eq__(self, other):
18191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18192 
 
18193 
  def __ne__(self, other):
18194 
    return not (self == other)
18195 
 
4495 rajveer 18196 
class validateReturnProduct_args:
18197 
  """
18198 
  Attributes:
18199 
   - orderId
18200 
   - isUsable
18201 
  """
18202 
 
18203 
  thrift_spec = (
18204 
    None, # 0
18205 
    (1, TType.I64, 'orderId', None, None, ), # 1
18206 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18207 
  )
18208 
 
18209 
  def __init__(self, orderId=None, isUsable=None,):
18210 
    self.orderId = orderId
18211 
    self.isUsable = isUsable
18212 
 
18213 
  def read(self, iprot):
18214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18216 
      return
18217 
    iprot.readStructBegin()
18218 
    while True:
18219 
      (fname, ftype, fid) = iprot.readFieldBegin()
18220 
      if ftype == TType.STOP:
18221 
        break
18222 
      if fid == 1:
18223 
        if ftype == TType.I64:
18224 
          self.orderId = iprot.readI64();
18225 
        else:
18226 
          iprot.skip(ftype)
18227 
      elif fid == 2:
18228 
        if ftype == TType.BOOL:
18229 
          self.isUsable = iprot.readBool();
18230 
        else:
18231 
          iprot.skip(ftype)
18232 
      else:
18233 
        iprot.skip(ftype)
18234 
      iprot.readFieldEnd()
18235 
    iprot.readStructEnd()
18236 
 
18237 
  def write(self, oprot):
18238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18240 
      return
18241 
    oprot.writeStructBegin('validateReturnProduct_args')
18242 
    if self.orderId is not None:
18243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18244 
      oprot.writeI64(self.orderId)
18245 
      oprot.writeFieldEnd()
18246 
    if self.isUsable is not None:
18247 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18248 
      oprot.writeBool(self.isUsable)
18249 
      oprot.writeFieldEnd()
18250 
    oprot.writeFieldStop()
18251 
    oprot.writeStructEnd()
18252 
 
18253 
  def validate(self):
18254 
    return
18255 
 
18256 
 
18257 
  def __repr__(self):
18258 
    L = ['%s=%r' % (key, value)
18259 
      for key, value in self.__dict__.iteritems()]
18260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18261 
 
18262 
  def __eq__(self, other):
18263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18264 
 
18265 
  def __ne__(self, other):
18266 
    return not (self == other)
18267 
 
18268 
class validateReturnProduct_result:
18269 
  """
18270 
  Attributes:
18271 
   - success
18272 
   - ex
18273 
  """
18274 
 
18275 
  thrift_spec = (
18276 
    (0, TType.BOOL, 'success', None, None, ), # 0
18277 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18278 
  )
18279 
 
18280 
  def __init__(self, success=None, ex=None,):
18281 
    self.success = success
18282 
    self.ex = ex
18283 
 
18284 
  def read(self, iprot):
18285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18287 
      return
18288 
    iprot.readStructBegin()
18289 
    while True:
18290 
      (fname, ftype, fid) = iprot.readFieldBegin()
18291 
      if ftype == TType.STOP:
18292 
        break
18293 
      if fid == 0:
18294 
        if ftype == TType.BOOL:
18295 
          self.success = iprot.readBool();
18296 
        else:
18297 
          iprot.skip(ftype)
18298 
      elif fid == 1:
18299 
        if ftype == TType.STRUCT:
18300 
          self.ex = TransactionServiceException()
18301 
          self.ex.read(iprot)
18302 
        else:
18303 
          iprot.skip(ftype)
18304 
      else:
18305 
        iprot.skip(ftype)
18306 
      iprot.readFieldEnd()
18307 
    iprot.readStructEnd()
18308 
 
18309 
  def write(self, oprot):
18310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18312 
      return
18313 
    oprot.writeStructBegin('validateReturnProduct_result')
18314 
    if self.success is not None:
18315 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18316 
      oprot.writeBool(self.success)
18317 
      oprot.writeFieldEnd()
18318 
    if self.ex is not None:
18319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18320 
      self.ex.write(oprot)
18321 
      oprot.writeFieldEnd()
18322 
    oprot.writeFieldStop()
18323 
    oprot.writeStructEnd()
18324 
 
18325 
  def validate(self):
18326 
    return
18327 
 
18328 
 
18329 
  def __repr__(self):
18330 
    L = ['%s=%r' % (key, value)
18331 
      for key, value in self.__dict__.iteritems()]
18332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18333 
 
18334 
  def __eq__(self, other):
18335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18336 
 
18337 
  def __ne__(self, other):
18338 
    return not (self == other)
18339 
 
2616 chandransh 18340 
class reshipOrder_args:
18341 
  """
18342 
  Attributes:
18343 
   - orderId
18344 
  """
2591 chandransh 18345 
 
2616 chandransh 18346 
  thrift_spec = (
18347 
    None, # 0
18348 
    (1, TType.I64, 'orderId', None, None, ), # 1
18349 
  )
18350 
 
18351 
  def __init__(self, orderId=None,):
18352 
    self.orderId = orderId
18353 
 
18354 
  def read(self, iprot):
18355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18357 
      return
18358 
    iprot.readStructBegin()
18359 
    while True:
18360 
      (fname, ftype, fid) = iprot.readFieldBegin()
18361 
      if ftype == TType.STOP:
18362 
        break
18363 
      if fid == 1:
18364 
        if ftype == TType.I64:
18365 
          self.orderId = iprot.readI64();
18366 
        else:
18367 
          iprot.skip(ftype)
18368 
      else:
18369 
        iprot.skip(ftype)
18370 
      iprot.readFieldEnd()
18371 
    iprot.readStructEnd()
18372 
 
18373 
  def write(self, oprot):
18374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18376 
      return
18377 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18378 
    if self.orderId is not None:
2616 chandransh 18379 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18380 
      oprot.writeI64(self.orderId)
18381 
      oprot.writeFieldEnd()
18382 
    oprot.writeFieldStop()
18383 
    oprot.writeStructEnd()
18384 
 
3431 rajveer 18385 
  def validate(self):
18386 
    return
18387 
 
18388 
 
2616 chandransh 18389 
  def __repr__(self):
18390 
    L = ['%s=%r' % (key, value)
18391 
      for key, value in self.__dict__.iteritems()]
18392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18393 
 
18394 
  def __eq__(self, other):
18395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18396 
 
18397 
  def __ne__(self, other):
18398 
    return not (self == other)
18399 
 
18400 
class reshipOrder_result:
18401 
  """
18402 
  Attributes:
18403 
   - success
18404 
   - ex
18405 
  """
18406 
 
18407 
  thrift_spec = (
18408 
    (0, TType.I64, 'success', None, None, ), # 0
18409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18410 
  )
18411 
 
18412 
  def __init__(self, success=None, ex=None,):
18413 
    self.success = success
18414 
    self.ex = ex
18415 
 
18416 
  def read(self, iprot):
18417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18419 
      return
18420 
    iprot.readStructBegin()
18421 
    while True:
18422 
      (fname, ftype, fid) = iprot.readFieldBegin()
18423 
      if ftype == TType.STOP:
18424 
        break
18425 
      if fid == 0:
18426 
        if ftype == TType.I64:
18427 
          self.success = iprot.readI64();
18428 
        else:
18429 
          iprot.skip(ftype)
18430 
      elif fid == 1:
18431 
        if ftype == TType.STRUCT:
18432 
          self.ex = TransactionServiceException()
18433 
          self.ex.read(iprot)
18434 
        else:
18435 
          iprot.skip(ftype)
18436 
      else:
18437 
        iprot.skip(ftype)
18438 
      iprot.readFieldEnd()
18439 
    iprot.readStructEnd()
18440 
 
18441 
  def write(self, oprot):
18442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18444 
      return
18445 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18446 
    if self.success is not None:
2616 chandransh 18447 
      oprot.writeFieldBegin('success', TType.I64, 0)
18448 
      oprot.writeI64(self.success)
18449 
      oprot.writeFieldEnd()
3431 rajveer 18450 
    if self.ex is not None:
2616 chandransh 18451 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18452 
      self.ex.write(oprot)
18453 
      oprot.writeFieldEnd()
18454 
    oprot.writeFieldStop()
18455 
    oprot.writeStructEnd()
18456 
 
3431 rajveer 18457 
  def validate(self):
18458 
    return
18459 
 
18460 
 
2616 chandransh 18461 
  def __repr__(self):
18462 
    L = ['%s=%r' % (key, value)
18463 
      for key, value in self.__dict__.iteritems()]
18464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18465 
 
18466 
  def __eq__(self, other):
18467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18468 
 
18469 
  def __ne__(self, other):
18470 
    return not (self == other)
18471 
 
18472 
class refundOrder_args:
18473 
  """
18474 
  Attributes:
18475 
   - orderId
3226 chandransh 18476 
   - refundedBy
18477 
   - reason
2616 chandransh 18478 
  """
18479 
 
18480 
  thrift_spec = (
18481 
    None, # 0
18482 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18483 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18484 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18485 
  )
18486 
 
3226 chandransh 18487 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18488 
    self.orderId = orderId
3226 chandransh 18489 
    self.refundedBy = refundedBy
18490 
    self.reason = reason
2616 chandransh 18491 
 
18492 
  def read(self, iprot):
18493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18495 
      return
18496 
    iprot.readStructBegin()
18497 
    while True:
18498 
      (fname, ftype, fid) = iprot.readFieldBegin()
18499 
      if ftype == TType.STOP:
18500 
        break
18501 
      if fid == 1:
18502 
        if ftype == TType.I64:
18503 
          self.orderId = iprot.readI64();
18504 
        else:
18505 
          iprot.skip(ftype)
3226 chandransh 18506 
      elif fid == 2:
18507 
        if ftype == TType.STRING:
18508 
          self.refundedBy = iprot.readString();
18509 
        else:
18510 
          iprot.skip(ftype)
18511 
      elif fid == 3:
18512 
        if ftype == TType.STRING:
18513 
          self.reason = iprot.readString();
18514 
        else:
18515 
          iprot.skip(ftype)
2616 chandransh 18516 
      else:
18517 
        iprot.skip(ftype)
18518 
      iprot.readFieldEnd()
18519 
    iprot.readStructEnd()
18520 
 
18521 
  def write(self, oprot):
18522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18524 
      return
18525 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18526 
    if self.orderId is not None:
2616 chandransh 18527 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18528 
      oprot.writeI64(self.orderId)
18529 
      oprot.writeFieldEnd()
3431 rajveer 18530 
    if self.refundedBy is not None:
3226 chandransh 18531 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18532 
      oprot.writeString(self.refundedBy)
18533 
      oprot.writeFieldEnd()
3431 rajveer 18534 
    if self.reason is not None:
3226 chandransh 18535 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18536 
      oprot.writeString(self.reason)
18537 
      oprot.writeFieldEnd()
2616 chandransh 18538 
    oprot.writeFieldStop()
18539 
    oprot.writeStructEnd()
18540 
 
3431 rajveer 18541 
  def validate(self):
18542 
    return
18543 
 
18544 
 
2616 chandransh 18545 
  def __repr__(self):
18546 
    L = ['%s=%r' % (key, value)
18547 
      for key, value in self.__dict__.iteritems()]
18548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18549 
 
18550 
  def __eq__(self, other):
18551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18552 
 
18553 
  def __ne__(self, other):
18554 
    return not (self == other)
18555 
 
18556 
class refundOrder_result:
18557 
  """
18558 
  Attributes:
18559 
   - success
18560 
   - ex
18561 
  """
18562 
 
18563 
  thrift_spec = (
18564 
    (0, TType.BOOL, 'success', None, None, ), # 0
18565 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18566 
  )
18567 
 
18568 
  def __init__(self, success=None, ex=None,):
18569 
    self.success = success
18570 
    self.ex = ex
18571 
 
18572 
  def read(self, iprot):
18573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18575 
      return
18576 
    iprot.readStructBegin()
18577 
    while True:
18578 
      (fname, ftype, fid) = iprot.readFieldBegin()
18579 
      if ftype == TType.STOP:
18580 
        break
18581 
      if fid == 0:
18582 
        if ftype == TType.BOOL:
18583 
          self.success = iprot.readBool();
18584 
        else:
18585 
          iprot.skip(ftype)
18586 
      elif fid == 1:
18587 
        if ftype == TType.STRUCT:
18588 
          self.ex = TransactionServiceException()
18589 
          self.ex.read(iprot)
18590 
        else:
18591 
          iprot.skip(ftype)
18592 
      else:
18593 
        iprot.skip(ftype)
18594 
      iprot.readFieldEnd()
18595 
    iprot.readStructEnd()
18596 
 
18597 
  def write(self, oprot):
18598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18600 
      return
18601 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18602 
    if self.success is not None:
2616 chandransh 18603 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18604 
      oprot.writeBool(self.success)
18605 
      oprot.writeFieldEnd()
3431 rajveer 18606 
    if self.ex is not None:
2616 chandransh 18607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18608 
      self.ex.write(oprot)
18609 
      oprot.writeFieldEnd()
18610 
    oprot.writeFieldStop()
18611 
    oprot.writeStructEnd()
18612 
 
3431 rajveer 18613 
  def validate(self):
18614 
    return
18615 
 
18616 
 
2616 chandransh 18617 
  def __repr__(self):
18618 
    L = ['%s=%r' % (key, value)
18619 
      for key, value in self.__dict__.iteritems()]
18620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18621 
 
18622 
  def __eq__(self, other):
18623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18624 
 
18625 
  def __ne__(self, other):
18626 
    return not (self == other)
18627 
 
2690 chandransh 18628 
class getReturnOrders_args:
18629 
  """
18630 
  Attributes:
18631 
   - warehouseId
18632 
   - fromDate
18633 
   - toDate
18634 
  """
2616 chandransh 18635 
 
2690 chandransh 18636 
  thrift_spec = (
18637 
    None, # 0
18638 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18639 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18640 
    (3, TType.I64, 'toDate', None, None, ), # 3
18641 
  )
18642 
 
18643 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18644 
    self.warehouseId = warehouseId
18645 
    self.fromDate = fromDate
18646 
    self.toDate = toDate
18647 
 
18648 
  def read(self, iprot):
18649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18651 
      return
18652 
    iprot.readStructBegin()
18653 
    while True:
18654 
      (fname, ftype, fid) = iprot.readFieldBegin()
18655 
      if ftype == TType.STOP:
18656 
        break
18657 
      if fid == 1:
18658 
        if ftype == TType.I64:
18659 
          self.warehouseId = iprot.readI64();
18660 
        else:
18661 
          iprot.skip(ftype)
18662 
      elif fid == 2:
18663 
        if ftype == TType.I64:
18664 
          self.fromDate = iprot.readI64();
18665 
        else:
18666 
          iprot.skip(ftype)
18667 
      elif fid == 3:
18668 
        if ftype == TType.I64:
18669 
          self.toDate = iprot.readI64();
18670 
        else:
18671 
          iprot.skip(ftype)
18672 
      else:
18673 
        iprot.skip(ftype)
18674 
      iprot.readFieldEnd()
18675 
    iprot.readStructEnd()
18676 
 
18677 
  def write(self, oprot):
18678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18680 
      return
18681 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18682 
    if self.warehouseId is not None:
2690 chandransh 18683 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18684 
      oprot.writeI64(self.warehouseId)
18685 
      oprot.writeFieldEnd()
3431 rajveer 18686 
    if self.fromDate is not None:
2690 chandransh 18687 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18688 
      oprot.writeI64(self.fromDate)
18689 
      oprot.writeFieldEnd()
3431 rajveer 18690 
    if self.toDate is not None:
2690 chandransh 18691 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18692 
      oprot.writeI64(self.toDate)
18693 
      oprot.writeFieldEnd()
18694 
    oprot.writeFieldStop()
18695 
    oprot.writeStructEnd()
18696 
 
3431 rajveer 18697 
  def validate(self):
18698 
    return
18699 
 
18700 
 
2690 chandransh 18701 
  def __repr__(self):
18702 
    L = ['%s=%r' % (key, value)
18703 
      for key, value in self.__dict__.iteritems()]
18704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18705 
 
18706 
  def __eq__(self, other):
18707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18708 
 
18709 
  def __ne__(self, other):
18710 
    return not (self == other)
18711 
 
18712 
class getReturnOrders_result:
18713 
  """
18714 
  Attributes:
18715 
   - success
18716 
  """
18717 
 
18718 
  thrift_spec = (
18719 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18720 
  )
18721 
 
18722 
  def __init__(self, success=None,):
18723 
    self.success = success
18724 
 
18725 
  def read(self, iprot):
18726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18728 
      return
18729 
    iprot.readStructBegin()
18730 
    while True:
18731 
      (fname, ftype, fid) = iprot.readFieldBegin()
18732 
      if ftype == TType.STOP:
18733 
        break
18734 
      if fid == 0:
18735 
        if ftype == TType.LIST:
18736 
          self.success = []
6188 rajveer 18737 
          (_etype442, _size439) = iprot.readListBegin()
18738 
          for _i443 in xrange(_size439):
18739 
            _elem444 = ReturnOrder()
18740 
            _elem444.read(iprot)
18741 
            self.success.append(_elem444)
2690 chandransh 18742 
          iprot.readListEnd()
18743 
        else:
18744 
          iprot.skip(ftype)
18745 
      else:
18746 
        iprot.skip(ftype)
18747 
      iprot.readFieldEnd()
18748 
    iprot.readStructEnd()
18749 
 
18750 
  def write(self, oprot):
18751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18753 
      return
18754 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18755 
    if self.success is not None:
2690 chandransh 18756 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18757 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18758 
      for iter445 in self.success:
18759 
        iter445.write(oprot)
2690 chandransh 18760 
      oprot.writeListEnd()
18761 
      oprot.writeFieldEnd()
18762 
    oprot.writeFieldStop()
18763 
    oprot.writeStructEnd()
18764 
 
3431 rajveer 18765 
  def validate(self):
18766 
    return
18767 
 
18768 
 
2690 chandransh 18769 
  def __repr__(self):
18770 
    L = ['%s=%r' % (key, value)
18771 
      for key, value in self.__dict__.iteritems()]
18772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18773 
 
18774 
  def __eq__(self, other):
18775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18776 
 
18777 
  def __ne__(self, other):
18778 
    return not (self == other)
18779 
 
5481 phani.kuma 18780 
class getAllReturnOrders_args:
18781 
  """
18782 
  Attributes:
18783 
   - onlyNotProcessed
18784 
   - fromDate
18785 
   - toDate
18786 
  """
18787 
 
18788 
  thrift_spec = (
18789 
    None, # 0
18790 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18791 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18792 
    (3, TType.I64, 'toDate', None, None, ), # 3
18793 
  )
18794 
 
18795 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18796 
    self.onlyNotProcessed = onlyNotProcessed
18797 
    self.fromDate = fromDate
18798 
    self.toDate = toDate
18799 
 
18800 
  def read(self, iprot):
18801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18803 
      return
18804 
    iprot.readStructBegin()
18805 
    while True:
18806 
      (fname, ftype, fid) = iprot.readFieldBegin()
18807 
      if ftype == TType.STOP:
18808 
        break
18809 
      if fid == 1:
18810 
        if ftype == TType.BOOL:
18811 
          self.onlyNotProcessed = iprot.readBool();
18812 
        else:
18813 
          iprot.skip(ftype)
18814 
      elif fid == 2:
18815 
        if ftype == TType.I64:
18816 
          self.fromDate = iprot.readI64();
18817 
        else:
18818 
          iprot.skip(ftype)
18819 
      elif fid == 3:
18820 
        if ftype == TType.I64:
18821 
          self.toDate = iprot.readI64();
18822 
        else:
18823 
          iprot.skip(ftype)
18824 
      else:
18825 
        iprot.skip(ftype)
18826 
      iprot.readFieldEnd()
18827 
    iprot.readStructEnd()
18828 
 
18829 
  def write(self, oprot):
18830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18832 
      return
18833 
    oprot.writeStructBegin('getAllReturnOrders_args')
18834 
    if self.onlyNotProcessed is not None:
18835 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18836 
      oprot.writeBool(self.onlyNotProcessed)
18837 
      oprot.writeFieldEnd()
18838 
    if self.fromDate is not None:
18839 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18840 
      oprot.writeI64(self.fromDate)
18841 
      oprot.writeFieldEnd()
18842 
    if self.toDate is not None:
18843 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18844 
      oprot.writeI64(self.toDate)
18845 
      oprot.writeFieldEnd()
18846 
    oprot.writeFieldStop()
18847 
    oprot.writeStructEnd()
18848 
 
18849 
  def validate(self):
18850 
    return
18851 
 
18852 
 
18853 
  def __repr__(self):
18854 
    L = ['%s=%r' % (key, value)
18855 
      for key, value in self.__dict__.iteritems()]
18856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18857 
 
18858 
  def __eq__(self, other):
18859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18860 
 
18861 
  def __ne__(self, other):
18862 
    return not (self == other)
18863 
 
18864 
class getAllReturnOrders_result:
18865 
  """
18866 
  Attributes:
18867 
   - success
18868 
  """
18869 
 
18870 
  thrift_spec = (
18871 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18872 
  )
18873 
 
18874 
  def __init__(self, success=None,):
18875 
    self.success = success
18876 
 
18877 
  def read(self, iprot):
18878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18880 
      return
18881 
    iprot.readStructBegin()
18882 
    while True:
18883 
      (fname, ftype, fid) = iprot.readFieldBegin()
18884 
      if ftype == TType.STOP:
18885 
        break
18886 
      if fid == 0:
18887 
        if ftype == TType.LIST:
18888 
          self.success = []
6188 rajveer 18889 
          (_etype449, _size446) = iprot.readListBegin()
18890 
          for _i450 in xrange(_size446):
18891 
            _elem451 = ReturnOrder()
18892 
            _elem451.read(iprot)
18893 
            self.success.append(_elem451)
5481 phani.kuma 18894 
          iprot.readListEnd()
18895 
        else:
18896 
          iprot.skip(ftype)
18897 
      else:
18898 
        iprot.skip(ftype)
18899 
      iprot.readFieldEnd()
18900 
    iprot.readStructEnd()
18901 
 
18902 
  def write(self, oprot):
18903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18905 
      return
18906 
    oprot.writeStructBegin('getAllReturnOrders_result')
18907 
    if self.success is not None:
18908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18910 
      for iter452 in self.success:
18911 
        iter452.write(oprot)
5481 phani.kuma 18912 
      oprot.writeListEnd()
18913 
      oprot.writeFieldEnd()
18914 
    oprot.writeFieldStop()
18915 
    oprot.writeStructEnd()
18916 
 
18917 
  def validate(self):
18918 
    return
18919 
 
18920 
 
18921 
  def __repr__(self):
18922 
    L = ['%s=%r' % (key, value)
18923 
      for key, value in self.__dict__.iteritems()]
18924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18925 
 
18926 
  def __eq__(self, other):
18927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18928 
 
18929 
  def __ne__(self, other):
18930 
    return not (self == other)
18931 
 
2700 chandransh 18932 
class getReturnOrder_args:
18933 
  """
18934 
  Attributes:
18935 
   - id
18936 
  """
18937 
 
18938 
  thrift_spec = (
18939 
    None, # 0
18940 
    (1, TType.I64, 'id', None, None, ), # 1
18941 
  )
18942 
 
18943 
  def __init__(self, id=None,):
18944 
    self.id = id
18945 
 
18946 
  def read(self, iprot):
18947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18949 
      return
18950 
    iprot.readStructBegin()
18951 
    while True:
18952 
      (fname, ftype, fid) = iprot.readFieldBegin()
18953 
      if ftype == TType.STOP:
18954 
        break
18955 
      if fid == 1:
18956 
        if ftype == TType.I64:
18957 
          self.id = iprot.readI64();
18958 
        else:
18959 
          iprot.skip(ftype)
18960 
      else:
18961 
        iprot.skip(ftype)
18962 
      iprot.readFieldEnd()
18963 
    iprot.readStructEnd()
18964 
 
18965 
  def write(self, oprot):
18966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18968 
      return
18969 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18970 
    if self.id is not None:
2700 chandransh 18971 
      oprot.writeFieldBegin('id', TType.I64, 1)
18972 
      oprot.writeI64(self.id)
18973 
      oprot.writeFieldEnd()
18974 
    oprot.writeFieldStop()
18975 
    oprot.writeStructEnd()
18976 
 
3431 rajveer 18977 
  def validate(self):
18978 
    return
18979 
 
18980 
 
2700 chandransh 18981 
  def __repr__(self):
18982 
    L = ['%s=%r' % (key, value)
18983 
      for key, value in self.__dict__.iteritems()]
18984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18985 
 
18986 
  def __eq__(self, other):
18987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18988 
 
18989 
  def __ne__(self, other):
18990 
    return not (self == other)
18991 
 
18992 
class getReturnOrder_result:
18993 
  """
18994 
  Attributes:
18995 
   - success
18996 
   - ex
18997 
  """
18998 
 
18999 
  thrift_spec = (
19000 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19002 
  )
19003 
 
19004 
  def __init__(self, success=None, ex=None,):
19005 
    self.success = success
19006 
    self.ex = ex
19007 
 
19008 
  def read(self, iprot):
19009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19011 
      return
19012 
    iprot.readStructBegin()
19013 
    while True:
19014 
      (fname, ftype, fid) = iprot.readFieldBegin()
19015 
      if ftype == TType.STOP:
19016 
        break
19017 
      if fid == 0:
19018 
        if ftype == TType.STRUCT:
19019 
          self.success = ReturnOrder()
19020 
          self.success.read(iprot)
19021 
        else:
19022 
          iprot.skip(ftype)
19023 
      elif fid == 1:
19024 
        if ftype == TType.STRUCT:
19025 
          self.ex = TransactionServiceException()
19026 
          self.ex.read(iprot)
19027 
        else:
19028 
          iprot.skip(ftype)
19029 
      else:
19030 
        iprot.skip(ftype)
19031 
      iprot.readFieldEnd()
19032 
    iprot.readStructEnd()
19033 
 
19034 
  def write(self, oprot):
19035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19037 
      return
19038 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19039 
    if self.success is not None:
2700 chandransh 19040 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19041 
      self.success.write(oprot)
19042 
      oprot.writeFieldEnd()
3431 rajveer 19043 
    if self.ex is not None:
2700 chandransh 19044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19045 
      self.ex.write(oprot)
19046 
      oprot.writeFieldEnd()
19047 
    oprot.writeFieldStop()
19048 
    oprot.writeStructEnd()
19049 
 
3431 rajveer 19050 
  def validate(self):
19051 
    return
19052 
 
19053 
 
2700 chandransh 19054 
  def __repr__(self):
19055 
    L = ['%s=%r' % (key, value)
19056 
      for key, value in self.__dict__.iteritems()]
19057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19058 
 
19059 
  def __eq__(self, other):
19060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19061 
 
19062 
  def __ne__(self, other):
19063 
    return not (self == other)
19064 
 
2690 chandransh 19065 
class processReturn_args:
19066 
  """
19067 
  Attributes:
19068 
   - returnOrderId
19069 
  """
19070 
 
19071 
  thrift_spec = (
19072 
    None, # 0
19073 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19074 
  )
19075 
 
19076 
  def __init__(self, returnOrderId=None,):
19077 
    self.returnOrderId = returnOrderId
19078 
 
19079 
  def read(self, iprot):
19080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19082 
      return
19083 
    iprot.readStructBegin()
19084 
    while True:
19085 
      (fname, ftype, fid) = iprot.readFieldBegin()
19086 
      if ftype == TType.STOP:
19087 
        break
19088 
      if fid == 1:
19089 
        if ftype == TType.I64:
19090 
          self.returnOrderId = iprot.readI64();
19091 
        else:
19092 
          iprot.skip(ftype)
19093 
      else:
19094 
        iprot.skip(ftype)
19095 
      iprot.readFieldEnd()
19096 
    iprot.readStructEnd()
19097 
 
19098 
  def write(self, oprot):
19099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19101 
      return
19102 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19103 
    if self.returnOrderId is not None:
2690 chandransh 19104 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19105 
      oprot.writeI64(self.returnOrderId)
19106 
      oprot.writeFieldEnd()
19107 
    oprot.writeFieldStop()
19108 
    oprot.writeStructEnd()
19109 
 
3431 rajveer 19110 
  def validate(self):
19111 
    return
19112 
 
19113 
 
2690 chandransh 19114 
  def __repr__(self):
19115 
    L = ['%s=%r' % (key, value)
19116 
      for key, value in self.__dict__.iteritems()]
19117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19118 
 
19119 
  def __eq__(self, other):
19120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19121 
 
19122 
  def __ne__(self, other):
19123 
    return not (self == other)
19124 
 
19125 
class processReturn_result:
19126 
  """
19127 
  Attributes:
19128 
   - ex
19129 
  """
19130 
 
19131 
  thrift_spec = (
19132 
    None, # 0
19133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19134 
  )
19135 
 
19136 
  def __init__(self, ex=None,):
19137 
    self.ex = ex
19138 
 
19139 
  def read(self, iprot):
19140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19142 
      return
19143 
    iprot.readStructBegin()
19144 
    while True:
19145 
      (fname, ftype, fid) = iprot.readFieldBegin()
19146 
      if ftype == TType.STOP:
19147 
        break
19148 
      if fid == 1:
19149 
        if ftype == TType.STRUCT:
19150 
          self.ex = TransactionServiceException()
19151 
          self.ex.read(iprot)
19152 
        else:
19153 
          iprot.skip(ftype)
19154 
      else:
19155 
        iprot.skip(ftype)
19156 
      iprot.readFieldEnd()
19157 
    iprot.readStructEnd()
19158 
 
19159 
  def write(self, oprot):
19160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19162 
      return
19163 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19164 
    if self.ex is not None:
2690 chandransh 19165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19166 
      self.ex.write(oprot)
19167 
      oprot.writeFieldEnd()
19168 
    oprot.writeFieldStop()
19169 
    oprot.writeStructEnd()
19170 
 
3431 rajveer 19171 
  def validate(self):
19172 
    return
19173 
 
19174 
 
2690 chandransh 19175 
  def __repr__(self):
19176 
    L = ['%s=%r' % (key, value)
19177 
      for key, value in self.__dict__.iteritems()]
19178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19179 
 
19180 
  def __eq__(self, other):
19181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19182 
 
19183 
  def __ne__(self, other):
19184 
    return not (self == other)
19185 
 
3451 chandransh 19186 
class updateWeight_args:
19187 
  """
19188 
  Attributes:
19189 
   - orderId
19190 
   - weight
19191 
  """
19192 
 
19193 
  thrift_spec = (
19194 
    None, # 0
19195 
    (1, TType.I64, 'orderId', None, None, ), # 1
19196 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19197 
  )
19198 
 
19199 
  def __init__(self, orderId=None, weight=None,):
19200 
    self.orderId = orderId
19201 
    self.weight = weight
19202 
 
19203 
  def read(self, iprot):
19204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19206 
      return
19207 
    iprot.readStructBegin()
19208 
    while True:
19209 
      (fname, ftype, fid) = iprot.readFieldBegin()
19210 
      if ftype == TType.STOP:
19211 
        break
19212 
      if fid == 1:
19213 
        if ftype == TType.I64:
19214 
          self.orderId = iprot.readI64();
19215 
        else:
19216 
          iprot.skip(ftype)
19217 
      elif fid == 2:
19218 
        if ftype == TType.DOUBLE:
19219 
          self.weight = iprot.readDouble();
19220 
        else:
19221 
          iprot.skip(ftype)
19222 
      else:
19223 
        iprot.skip(ftype)
19224 
      iprot.readFieldEnd()
19225 
    iprot.readStructEnd()
19226 
 
19227 
  def write(self, oprot):
19228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19230 
      return
19231 
    oprot.writeStructBegin('updateWeight_args')
19232 
    if self.orderId is not None:
19233 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19234 
      oprot.writeI64(self.orderId)
19235 
      oprot.writeFieldEnd()
19236 
    if self.weight is not None:
19237 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19238 
      oprot.writeDouble(self.weight)
19239 
      oprot.writeFieldEnd()
19240 
    oprot.writeFieldStop()
19241 
    oprot.writeStructEnd()
19242 
 
19243 
  def validate(self):
19244 
    return
19245 
 
19246 
 
19247 
  def __repr__(self):
19248 
    L = ['%s=%r' % (key, value)
19249 
      for key, value in self.__dict__.iteritems()]
19250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19251 
 
19252 
  def __eq__(self, other):
19253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19254 
 
19255 
  def __ne__(self, other):
19256 
    return not (self == other)
19257 
 
19258 
class updateWeight_result:
19259 
  """
19260 
  Attributes:
19261 
   - success
19262 
   - ex
19263 
  """
19264 
 
19265 
  thrift_spec = (
19266 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19268 
  )
19269 
 
19270 
  def __init__(self, success=None, ex=None,):
19271 
    self.success = success
19272 
    self.ex = ex
19273 
 
19274 
  def read(self, iprot):
19275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19277 
      return
19278 
    iprot.readStructBegin()
19279 
    while True:
19280 
      (fname, ftype, fid) = iprot.readFieldBegin()
19281 
      if ftype == TType.STOP:
19282 
        break
19283 
      if fid == 0:
19284 
        if ftype == TType.STRUCT:
19285 
          self.success = Order()
19286 
          self.success.read(iprot)
19287 
        else:
19288 
          iprot.skip(ftype)
19289 
      elif fid == 1:
19290 
        if ftype == TType.STRUCT:
19291 
          self.ex = TransactionServiceException()
19292 
          self.ex.read(iprot)
19293 
        else:
19294 
          iprot.skip(ftype)
19295 
      else:
19296 
        iprot.skip(ftype)
19297 
      iprot.readFieldEnd()
19298 
    iprot.readStructEnd()
19299 
 
19300 
  def write(self, oprot):
19301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19303 
      return
19304 
    oprot.writeStructBegin('updateWeight_result')
19305 
    if self.success is not None:
19306 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19307 
      self.success.write(oprot)
19308 
      oprot.writeFieldEnd()
19309 
    if self.ex is not None:
19310 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19311 
      self.ex.write(oprot)
19312 
      oprot.writeFieldEnd()
19313 
    oprot.writeFieldStop()
19314 
    oprot.writeStructEnd()
19315 
 
19316 
  def validate(self):
19317 
    return
19318 
 
19319 
 
19320 
  def __repr__(self):
19321 
    L = ['%s=%r' % (key, value)
19322 
      for key, value in self.__dict__.iteritems()]
19323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19324 
 
19325 
  def __eq__(self, other):
19326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19327 
 
19328 
  def __ne__(self, other):
19329 
    return not (self == other)
3469 chandransh 19330 
 
19331 
class changeItem_args:
19332 
  """
19333 
  Attributes:
19334 
   - orderId
19335 
   - itemId
19336 
  """
19337 
 
19338 
  thrift_spec = (
19339 
    None, # 0
19340 
    (1, TType.I64, 'orderId', None, None, ), # 1
19341 
    (2, TType.I64, 'itemId', None, None, ), # 2
19342 
  )
19343 
 
19344 
  def __init__(self, orderId=None, itemId=None,):
19345 
    self.orderId = orderId
19346 
    self.itemId = itemId
19347 
 
19348 
  def read(self, iprot):
19349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19351 
      return
19352 
    iprot.readStructBegin()
19353 
    while True:
19354 
      (fname, ftype, fid) = iprot.readFieldBegin()
19355 
      if ftype == TType.STOP:
19356 
        break
19357 
      if fid == 1:
19358 
        if ftype == TType.I64:
19359 
          self.orderId = iprot.readI64();
19360 
        else:
19361 
          iprot.skip(ftype)
19362 
      elif fid == 2:
19363 
        if ftype == TType.I64:
19364 
          self.itemId = iprot.readI64();
19365 
        else:
19366 
          iprot.skip(ftype)
19367 
      else:
19368 
        iprot.skip(ftype)
19369 
      iprot.readFieldEnd()
19370 
    iprot.readStructEnd()
19371 
 
19372 
  def write(self, oprot):
19373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19375 
      return
19376 
    oprot.writeStructBegin('changeItem_args')
19377 
    if self.orderId is not None:
19378 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19379 
      oprot.writeI64(self.orderId)
19380 
      oprot.writeFieldEnd()
19381 
    if self.itemId is not None:
19382 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19383 
      oprot.writeI64(self.itemId)
19384 
      oprot.writeFieldEnd()
19385 
    oprot.writeFieldStop()
19386 
    oprot.writeStructEnd()
19387 
 
19388 
  def validate(self):
19389 
    return
19390 
 
19391 
 
19392 
  def __repr__(self):
19393 
    L = ['%s=%r' % (key, value)
19394 
      for key, value in self.__dict__.iteritems()]
19395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19396 
 
19397 
  def __eq__(self, other):
19398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19399 
 
19400 
  def __ne__(self, other):
19401 
    return not (self == other)
19402 
 
19403 
class changeItem_result:
19404 
  """
19405 
  Attributes:
19406 
   - success
19407 
   - ex
19408 
  """
19409 
 
19410 
  thrift_spec = (
19411 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19413 
  )
19414 
 
19415 
  def __init__(self, success=None, ex=None,):
19416 
    self.success = success
19417 
    self.ex = ex
19418 
 
19419 
  def read(self, iprot):
19420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19422 
      return
19423 
    iprot.readStructBegin()
19424 
    while True:
19425 
      (fname, ftype, fid) = iprot.readFieldBegin()
19426 
      if ftype == TType.STOP:
19427 
        break
19428 
      if fid == 0:
19429 
        if ftype == TType.STRUCT:
19430 
          self.success = Order()
19431 
          self.success.read(iprot)
19432 
        else:
19433 
          iprot.skip(ftype)
19434 
      elif fid == 1:
19435 
        if ftype == TType.STRUCT:
19436 
          self.ex = TransactionServiceException()
19437 
          self.ex.read(iprot)
19438 
        else:
19439 
          iprot.skip(ftype)
19440 
      else:
19441 
        iprot.skip(ftype)
19442 
      iprot.readFieldEnd()
19443 
    iprot.readStructEnd()
19444 
 
19445 
  def write(self, oprot):
19446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19448 
      return
19449 
    oprot.writeStructBegin('changeItem_result')
19450 
    if self.success is not None:
19451 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19452 
      self.success.write(oprot)
19453 
      oprot.writeFieldEnd()
19454 
    if self.ex is not None:
19455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19456 
      self.ex.write(oprot)
19457 
      oprot.writeFieldEnd()
19458 
    oprot.writeFieldStop()
19459 
    oprot.writeStructEnd()
19460 
 
19461 
  def validate(self):
19462 
    return
19463 
 
19464 
 
19465 
  def __repr__(self):
19466 
    L = ['%s=%r' % (key, value)
19467 
      for key, value in self.__dict__.iteritems()]
19468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19469 
 
19470 
  def __eq__(self, other):
19471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19472 
 
19473 
  def __ne__(self, other):
19474 
    return not (self == other)
19475 
 
19476 
class shiftToWarehouse_args:
19477 
  """
19478 
  Attributes:
19479 
   - orderId
19480 
   - warehouseId
19481 
  """
19482 
 
19483 
  thrift_spec = (
19484 
    None, # 0
19485 
    (1, TType.I64, 'orderId', None, None, ), # 1
19486 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19487 
  )
19488 
 
19489 
  def __init__(self, orderId=None, warehouseId=None,):
19490 
    self.orderId = orderId
19491 
    self.warehouseId = warehouseId
19492 
 
19493 
  def read(self, iprot):
19494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19496 
      return
19497 
    iprot.readStructBegin()
19498 
    while True:
19499 
      (fname, ftype, fid) = iprot.readFieldBegin()
19500 
      if ftype == TType.STOP:
19501 
        break
19502 
      if fid == 1:
19503 
        if ftype == TType.I64:
19504 
          self.orderId = iprot.readI64();
19505 
        else:
19506 
          iprot.skip(ftype)
19507 
      elif fid == 2:
19508 
        if ftype == TType.I64:
19509 
          self.warehouseId = iprot.readI64();
19510 
        else:
19511 
          iprot.skip(ftype)
19512 
      else:
19513 
        iprot.skip(ftype)
19514 
      iprot.readFieldEnd()
19515 
    iprot.readStructEnd()
19516 
 
19517 
  def write(self, oprot):
19518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19520 
      return
19521 
    oprot.writeStructBegin('shiftToWarehouse_args')
19522 
    if self.orderId is not None:
19523 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19524 
      oprot.writeI64(self.orderId)
19525 
      oprot.writeFieldEnd()
19526 
    if self.warehouseId is not None:
19527 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19528 
      oprot.writeI64(self.warehouseId)
19529 
      oprot.writeFieldEnd()
19530 
    oprot.writeFieldStop()
19531 
    oprot.writeStructEnd()
19532 
 
19533 
  def validate(self):
19534 
    return
19535 
 
19536 
 
19537 
  def __repr__(self):
19538 
    L = ['%s=%r' % (key, value)
19539 
      for key, value in self.__dict__.iteritems()]
19540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19541 
 
19542 
  def __eq__(self, other):
19543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19544 
 
19545 
  def __ne__(self, other):
19546 
    return not (self == other)
19547 
 
19548 
class shiftToWarehouse_result:
19549 
  """
19550 
  Attributes:
19551 
   - success
19552 
   - ex
19553 
  """
19554 
 
19555 
  thrift_spec = (
19556 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19557 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19558 
  )
19559 
 
19560 
  def __init__(self, success=None, ex=None,):
19561 
    self.success = success
19562 
    self.ex = ex
19563 
 
19564 
  def read(self, iprot):
19565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19567 
      return
19568 
    iprot.readStructBegin()
19569 
    while True:
19570 
      (fname, ftype, fid) = iprot.readFieldBegin()
19571 
      if ftype == TType.STOP:
19572 
        break
19573 
      if fid == 0:
19574 
        if ftype == TType.STRUCT:
19575 
          self.success = Order()
19576 
          self.success.read(iprot)
19577 
        else:
19578 
          iprot.skip(ftype)
19579 
      elif fid == 1:
19580 
        if ftype == TType.STRUCT:
19581 
          self.ex = TransactionServiceException()
19582 
          self.ex.read(iprot)
19583 
        else:
19584 
          iprot.skip(ftype)
19585 
      else:
19586 
        iprot.skip(ftype)
19587 
      iprot.readFieldEnd()
19588 
    iprot.readStructEnd()
19589 
 
19590 
  def write(self, oprot):
19591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19593 
      return
19594 
    oprot.writeStructBegin('shiftToWarehouse_result')
19595 
    if self.success is not None:
19596 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19597 
      self.success.write(oprot)
19598 
      oprot.writeFieldEnd()
19599 
    if self.ex is not None:
19600 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19601 
      self.ex.write(oprot)
19602 
      oprot.writeFieldEnd()
19603 
    oprot.writeFieldStop()
19604 
    oprot.writeStructEnd()
19605 
 
19606 
  def validate(self):
19607 
    return
19608 
 
19609 
 
19610 
  def __repr__(self):
19611 
    L = ['%s=%r' % (key, value)
19612 
      for key, value in self.__dict__.iteritems()]
19613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19614 
 
19615 
  def __eq__(self, other):
19616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19617 
 
19618 
  def __ne__(self, other):
19619 
    return not (self == other)
3553 chandransh 19620 
 
19621 
class addDelayReason_args:
19622 
  """
19623 
  Attributes:
19624 
   - orderId
19625 
   - delayReason
3986 chandransh 19626 
   - furtherDelay
4647 rajveer 19627 
   - delayReasonText
3553 chandransh 19628 
  """
19629 
 
19630 
  thrift_spec = (
19631 
    None, # 0
19632 
    (1, TType.I64, 'orderId', None, None, ), # 1
19633 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19634 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19635 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19636 
  )
19637 
 
4647 rajveer 19638 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19639 
    self.orderId = orderId
19640 
    self.delayReason = delayReason
3986 chandransh 19641 
    self.furtherDelay = furtherDelay
4647 rajveer 19642 
    self.delayReasonText = delayReasonText
3553 chandransh 19643 
 
19644 
  def read(self, iprot):
19645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19647 
      return
19648 
    iprot.readStructBegin()
19649 
    while True:
19650 
      (fname, ftype, fid) = iprot.readFieldBegin()
19651 
      if ftype == TType.STOP:
19652 
        break
19653 
      if fid == 1:
19654 
        if ftype == TType.I64:
19655 
          self.orderId = iprot.readI64();
19656 
        else:
19657 
          iprot.skip(ftype)
19658 
      elif fid == 2:
19659 
        if ftype == TType.I32:
19660 
          self.delayReason = iprot.readI32();
19661 
        else:
19662 
          iprot.skip(ftype)
3986 chandransh 19663 
      elif fid == 3:
19664 
        if ftype == TType.I64:
19665 
          self.furtherDelay = iprot.readI64();
19666 
        else:
19667 
          iprot.skip(ftype)
4647 rajveer 19668 
      elif fid == 4:
19669 
        if ftype == TType.STRING:
19670 
          self.delayReasonText = iprot.readString();
19671 
        else:
19672 
          iprot.skip(ftype)
3553 chandransh 19673 
      else:
19674 
        iprot.skip(ftype)
19675 
      iprot.readFieldEnd()
19676 
    iprot.readStructEnd()
19677 
 
19678 
  def write(self, oprot):
19679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19681 
      return
19682 
    oprot.writeStructBegin('addDelayReason_args')
19683 
    if self.orderId is not None:
19684 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19685 
      oprot.writeI64(self.orderId)
19686 
      oprot.writeFieldEnd()
19687 
    if self.delayReason is not None:
19688 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19689 
      oprot.writeI32(self.delayReason)
19690 
      oprot.writeFieldEnd()
3986 chandransh 19691 
    if self.furtherDelay is not None:
19692 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19693 
      oprot.writeI64(self.furtherDelay)
19694 
      oprot.writeFieldEnd()
4647 rajveer 19695 
    if self.delayReasonText is not None:
19696 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19697 
      oprot.writeString(self.delayReasonText)
19698 
      oprot.writeFieldEnd()
3553 chandransh 19699 
    oprot.writeFieldStop()
19700 
    oprot.writeStructEnd()
19701 
 
19702 
  def validate(self):
19703 
    return
19704 
 
19705 
 
19706 
  def __repr__(self):
19707 
    L = ['%s=%r' % (key, value)
19708 
      for key, value in self.__dict__.iteritems()]
19709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19710 
 
19711 
  def __eq__(self, other):
19712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19713 
 
19714 
  def __ne__(self, other):
19715 
    return not (self == other)
19716 
 
19717 
class addDelayReason_result:
19718 
  """
19719 
  Attributes:
19720 
   - success
19721 
   - ex
19722 
  """
19723 
 
19724 
  thrift_spec = (
19725 
    (0, TType.BOOL, 'success', None, None, ), # 0
19726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19727 
  )
19728 
 
19729 
  def __init__(self, success=None, ex=None,):
19730 
    self.success = success
19731 
    self.ex = ex
19732 
 
19733 
  def read(self, iprot):
19734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19736 
      return
19737 
    iprot.readStructBegin()
19738 
    while True:
19739 
      (fname, ftype, fid) = iprot.readFieldBegin()
19740 
      if ftype == TType.STOP:
19741 
        break
19742 
      if fid == 0:
19743 
        if ftype == TType.BOOL:
19744 
          self.success = iprot.readBool();
19745 
        else:
19746 
          iprot.skip(ftype)
19747 
      elif fid == 1:
19748 
        if ftype == TType.STRUCT:
19749 
          self.ex = TransactionServiceException()
19750 
          self.ex.read(iprot)
19751 
        else:
19752 
          iprot.skip(ftype)
19753 
      else:
19754 
        iprot.skip(ftype)
19755 
      iprot.readFieldEnd()
19756 
    iprot.readStructEnd()
19757 
 
19758 
  def write(self, oprot):
19759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19761 
      return
19762 
    oprot.writeStructBegin('addDelayReason_result')
19763 
    if self.success is not None:
19764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19765 
      oprot.writeBool(self.success)
19766 
      oprot.writeFieldEnd()
19767 
    if self.ex is not None:
19768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19769 
      self.ex.write(oprot)
19770 
      oprot.writeFieldEnd()
19771 
    oprot.writeFieldStop()
19772 
    oprot.writeStructEnd()
19773 
 
19774 
  def validate(self):
19775 
    return
19776 
 
19777 
 
19778 
  def __repr__(self):
19779 
    L = ['%s=%r' % (key, value)
19780 
      for key, value in self.__dict__.iteritems()]
19781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19782 
 
19783 
  def __eq__(self, other):
19784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19785 
 
19786 
  def __ne__(self, other):
19787 
    return not (self == other)
3956 chandransh 19788 
 
19789 
class reconcileCodCollection_args:
19790 
  """
19791 
  Attributes:
19792 
   - collectedAmountMap
19793 
   - xferBy
19794 
   - xferTxnId
19795 
   - xferDate
19796 
  """
19797 
 
19798 
  thrift_spec = (
19799 
    None, # 0
19800 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19801 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19802 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19803 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19804 
  )
19805 
 
19806 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19807 
    self.collectedAmountMap = collectedAmountMap
19808 
    self.xferBy = xferBy
19809 
    self.xferTxnId = xferTxnId
19810 
    self.xferDate = xferDate
19811 
 
19812 
  def read(self, iprot):
19813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19815 
      return
19816 
    iprot.readStructBegin()
19817 
    while True:
19818 
      (fname, ftype, fid) = iprot.readFieldBegin()
19819 
      if ftype == TType.STOP:
19820 
        break
19821 
      if fid == 1:
19822 
        if ftype == TType.MAP:
19823 
          self.collectedAmountMap = {}
6188 rajveer 19824 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19825 
          for _i457 in xrange(_size453):
19826 
            _key458 = iprot.readString();
19827 
            _val459 = iprot.readDouble();
19828 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19829 
          iprot.readMapEnd()
19830 
        else:
19831 
          iprot.skip(ftype)
19832 
      elif fid == 2:
19833 
        if ftype == TType.STRING:
19834 
          self.xferBy = iprot.readString();
19835 
        else:
19836 
          iprot.skip(ftype)
19837 
      elif fid == 3:
19838 
        if ftype == TType.STRING:
19839 
          self.xferTxnId = iprot.readString();
19840 
        else:
19841 
          iprot.skip(ftype)
19842 
      elif fid == 4:
19843 
        if ftype == TType.I64:
19844 
          self.xferDate = iprot.readI64();
19845 
        else:
19846 
          iprot.skip(ftype)
19847 
      else:
19848 
        iprot.skip(ftype)
19849 
      iprot.readFieldEnd()
19850 
    iprot.readStructEnd()
19851 
 
19852 
  def write(self, oprot):
19853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19855 
      return
19856 
    oprot.writeStructBegin('reconcileCodCollection_args')
19857 
    if self.collectedAmountMap is not None:
19858 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19859 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19860 
      for kiter460,viter461 in self.collectedAmountMap.items():
19861 
        oprot.writeString(kiter460)
19862 
        oprot.writeDouble(viter461)
3956 chandransh 19863 
      oprot.writeMapEnd()
19864 
      oprot.writeFieldEnd()
19865 
    if self.xferBy is not None:
19866 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19867 
      oprot.writeString(self.xferBy)
19868 
      oprot.writeFieldEnd()
19869 
    if self.xferTxnId is not None:
19870 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19871 
      oprot.writeString(self.xferTxnId)
19872 
      oprot.writeFieldEnd()
19873 
    if self.xferDate is not None:
19874 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19875 
      oprot.writeI64(self.xferDate)
19876 
      oprot.writeFieldEnd()
19877 
    oprot.writeFieldStop()
19878 
    oprot.writeStructEnd()
19879 
 
19880 
  def validate(self):
19881 
    return
19882 
 
19883 
 
19884 
  def __repr__(self):
19885 
    L = ['%s=%r' % (key, value)
19886 
      for key, value in self.__dict__.iteritems()]
19887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19888 
 
19889 
  def __eq__(self, other):
19890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19891 
 
19892 
  def __ne__(self, other):
19893 
    return not (self == other)
19894 
 
19895 
class reconcileCodCollection_result:
19896 
  """
19897 
  Attributes:
19898 
   - success
19899 
   - ex
19900 
  """
19901 
 
19902 
  thrift_spec = (
19903 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19905 
  )
19906 
 
19907 
  def __init__(self, success=None, ex=None,):
19908 
    self.success = success
19909 
    self.ex = ex
19910 
 
19911 
  def read(self, iprot):
19912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19914 
      return
19915 
    iprot.readStructBegin()
19916 
    while True:
19917 
      (fname, ftype, fid) = iprot.readFieldBegin()
19918 
      if ftype == TType.STOP:
19919 
        break
19920 
      if fid == 0:
19921 
        if ftype == TType.MAP:
19922 
          self.success = {}
6188 rajveer 19923 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19924 
          for _i466 in xrange(_size462):
19925 
            _key467 = iprot.readString();
19926 
            _val468 = iprot.readString();
19927 
            self.success[_key467] = _val468
3956 chandransh 19928 
          iprot.readMapEnd()
19929 
        else:
19930 
          iprot.skip(ftype)
19931 
      elif fid == 1:
19932 
        if ftype == TType.STRUCT:
19933 
          self.ex = TransactionServiceException()
19934 
          self.ex.read(iprot)
19935 
        else:
19936 
          iprot.skip(ftype)
19937 
      else:
19938 
        iprot.skip(ftype)
19939 
      iprot.readFieldEnd()
19940 
    iprot.readStructEnd()
19941 
 
19942 
  def write(self, oprot):
19943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19945 
      return
19946 
    oprot.writeStructBegin('reconcileCodCollection_result')
19947 
    if self.success is not None:
19948 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19949 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19950 
      for kiter469,viter470 in self.success.items():
19951 
        oprot.writeString(kiter469)
19952 
        oprot.writeString(viter470)
3956 chandransh 19953 
      oprot.writeMapEnd()
19954 
      oprot.writeFieldEnd()
19955 
    if self.ex is not None:
19956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19957 
      self.ex.write(oprot)
19958 
      oprot.writeFieldEnd()
19959 
    oprot.writeFieldStop()
19960 
    oprot.writeStructEnd()
19961 
 
19962 
  def validate(self):
19963 
    return
19964 
 
19965 
 
19966 
  def __repr__(self):
19967 
    L = ['%s=%r' % (key, value)
19968 
      for key, value in self.__dict__.iteritems()]
19969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19970 
 
19971 
  def __eq__(self, other):
19972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19973 
 
19974 
  def __ne__(self, other):
19975 
    return not (self == other)
4008 mandeep.dh 19976 
 
19977 
class getTransactionsRequiringExtraProcessing_args:
19978 
  """
19979 
  Attributes:
19980 
   - category
19981 
  """
19982 
 
19983 
  thrift_spec = (
19984 
    None, # 0
19985 
    (1, TType.I32, 'category', None, None, ), # 1
19986 
  )
19987 
 
19988 
  def __init__(self, category=None,):
19989 
    self.category = category
19990 
 
19991 
  def read(self, iprot):
19992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19994 
      return
19995 
    iprot.readStructBegin()
19996 
    while True:
19997 
      (fname, ftype, fid) = iprot.readFieldBegin()
19998 
      if ftype == TType.STOP:
19999 
        break
20000 
      if fid == 1:
20001 
        if ftype == TType.I32:
20002 
          self.category = iprot.readI32();
20003 
        else:
20004 
          iprot.skip(ftype)
20005 
      else:
20006 
        iprot.skip(ftype)
20007 
      iprot.readFieldEnd()
20008 
    iprot.readStructEnd()
20009 
 
20010 
  def write(self, oprot):
20011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20013 
      return
20014 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20015 
    if self.category is not None:
20016 
      oprot.writeFieldBegin('category', TType.I32, 1)
20017 
      oprot.writeI32(self.category)
20018 
      oprot.writeFieldEnd()
20019 
    oprot.writeFieldStop()
20020 
    oprot.writeStructEnd()
20021 
 
20022 
  def validate(self):
20023 
    return
20024 
 
20025 
 
20026 
  def __repr__(self):
20027 
    L = ['%s=%r' % (key, value)
20028 
      for key, value in self.__dict__.iteritems()]
20029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20030 
 
20031 
  def __eq__(self, other):
20032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20033 
 
20034 
  def __ne__(self, other):
20035 
    return not (self == other)
20036 
 
20037 
class getTransactionsRequiringExtraProcessing_result:
20038 
  """
20039 
  Attributes:
20040 
   - success
20041 
  """
20042 
 
20043 
  thrift_spec = (
20044 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20045 
  )
20046 
 
20047 
  def __init__(self, success=None,):
20048 
    self.success = success
20049 
 
20050 
  def read(self, iprot):
20051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20053 
      return
20054 
    iprot.readStructBegin()
20055 
    while True:
20056 
      (fname, ftype, fid) = iprot.readFieldBegin()
20057 
      if ftype == TType.STOP:
20058 
        break
20059 
      if fid == 0:
20060 
        if ftype == TType.LIST:
20061 
          self.success = []
6188 rajveer 20062 
          (_etype474, _size471) = iprot.readListBegin()
20063 
          for _i475 in xrange(_size471):
20064 
            _elem476 = iprot.readI64();
20065 
            self.success.append(_elem476)
4008 mandeep.dh 20066 
          iprot.readListEnd()
20067 
        else:
20068 
          iprot.skip(ftype)
20069 
      else:
20070 
        iprot.skip(ftype)
20071 
      iprot.readFieldEnd()
20072 
    iprot.readStructEnd()
20073 
 
20074 
  def write(self, oprot):
20075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20077 
      return
20078 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20079 
    if self.success is not None:
20080 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20081 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20082 
      for iter477 in self.success:
20083 
        oprot.writeI64(iter477)
4008 mandeep.dh 20084 
      oprot.writeListEnd()
20085 
      oprot.writeFieldEnd()
20086 
    oprot.writeFieldStop()
20087 
    oprot.writeStructEnd()
20088 
 
20089 
  def validate(self):
20090 
    return
20091 
 
20092 
 
20093 
  def __repr__(self):
20094 
    L = ['%s=%r' % (key, value)
20095 
      for key, value in self.__dict__.iteritems()]
20096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20097 
 
20098 
  def __eq__(self, other):
20099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20100 
 
20101 
  def __ne__(self, other):
20102 
    return not (self == other)
20103 
 
20104 
class markTransactionAsProcessed_args:
20105 
  """
20106 
  Attributes:
20107 
   - transactionId
20108 
   - category
20109 
  """
20110 
 
20111 
  thrift_spec = (
20112 
    None, # 0
20113 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20114 
    (2, TType.I32, 'category', None, None, ), # 2
20115 
  )
20116 
 
20117 
  def __init__(self, transactionId=None, category=None,):
20118 
    self.transactionId = transactionId
20119 
    self.category = category
20120 
 
20121 
  def read(self, iprot):
20122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20124 
      return
20125 
    iprot.readStructBegin()
20126 
    while True:
20127 
      (fname, ftype, fid) = iprot.readFieldBegin()
20128 
      if ftype == TType.STOP:
20129 
        break
20130 
      if fid == 1:
20131 
        if ftype == TType.I64:
20132 
          self.transactionId = iprot.readI64();
20133 
        else:
20134 
          iprot.skip(ftype)
20135 
      elif fid == 2:
20136 
        if ftype == TType.I32:
20137 
          self.category = iprot.readI32();
20138 
        else:
20139 
          iprot.skip(ftype)
20140 
      else:
20141 
        iprot.skip(ftype)
20142 
      iprot.readFieldEnd()
20143 
    iprot.readStructEnd()
20144 
 
20145 
  def write(self, oprot):
20146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20148 
      return
20149 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20150 
    if self.transactionId is not None:
20151 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20152 
      oprot.writeI64(self.transactionId)
20153 
      oprot.writeFieldEnd()
20154 
    if self.category is not None:
20155 
      oprot.writeFieldBegin('category', TType.I32, 2)
20156 
      oprot.writeI32(self.category)
20157 
      oprot.writeFieldEnd()
20158 
    oprot.writeFieldStop()
20159 
    oprot.writeStructEnd()
20160 
 
20161 
  def validate(self):
20162 
    return
20163 
 
20164 
 
20165 
  def __repr__(self):
20166 
    L = ['%s=%r' % (key, value)
20167 
      for key, value in self.__dict__.iteritems()]
20168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20169 
 
20170 
  def __eq__(self, other):
20171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20172 
 
20173 
  def __ne__(self, other):
20174 
    return not (self == other)
20175 
 
20176 
class markTransactionAsProcessed_result:
20177 
 
20178 
  thrift_spec = (
20179 
  )
20180 
 
20181 
  def read(self, iprot):
20182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20184 
      return
20185 
    iprot.readStructBegin()
20186 
    while True:
20187 
      (fname, ftype, fid) = iprot.readFieldBegin()
20188 
      if ftype == TType.STOP:
20189 
        break
20190 
      else:
20191 
        iprot.skip(ftype)
20192 
      iprot.readFieldEnd()
20193 
    iprot.readStructEnd()
20194 
 
20195 
  def write(self, oprot):
20196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20198 
      return
20199 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20200 
    oprot.writeFieldStop()
20201 
    oprot.writeStructEnd()
20202 
 
20203 
  def validate(self):
20204 
    return
20205 
 
20206 
 
20207 
  def __repr__(self):
20208 
    L = ['%s=%r' % (key, value)
20209 
      for key, value in self.__dict__.iteritems()]
20210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20211 
 
20212 
  def __eq__(self, other):
20213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20214 
 
20215 
  def __ne__(self, other):
20216 
    return not (self == other)
4018 chandransh 20217 
 
20218 
class getItemWiseRiskyOrdersCount_args:
20219 
 
20220 
  thrift_spec = (
20221 
  )
20222 
 
20223 
  def read(self, iprot):
20224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20226 
      return
20227 
    iprot.readStructBegin()
20228 
    while True:
20229 
      (fname, ftype, fid) = iprot.readFieldBegin()
20230 
      if ftype == TType.STOP:
20231 
        break
20232 
      else:
20233 
        iprot.skip(ftype)
20234 
      iprot.readFieldEnd()
20235 
    iprot.readStructEnd()
20236 
 
20237 
  def write(self, oprot):
20238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20240 
      return
20241 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20242 
    oprot.writeFieldStop()
20243 
    oprot.writeStructEnd()
20244 
 
20245 
  def validate(self):
20246 
    return
20247 
 
20248 
 
20249 
  def __repr__(self):
20250 
    L = ['%s=%r' % (key, value)
20251 
      for key, value in self.__dict__.iteritems()]
20252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20253 
 
20254 
  def __eq__(self, other):
20255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20256 
 
20257 
  def __ne__(self, other):
20258 
    return not (self == other)
20259 
 
20260 
class getItemWiseRiskyOrdersCount_result:
20261 
  """
20262 
  Attributes:
20263 
   - success
20264 
  """
20265 
 
20266 
  thrift_spec = (
20267 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20268 
  )
20269 
 
20270 
  def __init__(self, success=None,):
20271 
    self.success = success
20272 
 
20273 
  def read(self, iprot):
20274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20276 
      return
20277 
    iprot.readStructBegin()
20278 
    while True:
20279 
      (fname, ftype, fid) = iprot.readFieldBegin()
20280 
      if ftype == TType.STOP:
20281 
        break
20282 
      if fid == 0:
20283 
        if ftype == TType.MAP:
20284 
          self.success = {}
6188 rajveer 20285 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20286 
          for _i482 in xrange(_size478):
20287 
            _key483 = iprot.readI64();
20288 
            _val484 = iprot.readI64();
20289 
            self.success[_key483] = _val484
4018 chandransh 20290 
          iprot.readMapEnd()
20291 
        else:
20292 
          iprot.skip(ftype)
20293 
      else:
20294 
        iprot.skip(ftype)
20295 
      iprot.readFieldEnd()
20296 
    iprot.readStructEnd()
20297 
 
20298 
  def write(self, oprot):
20299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20301 
      return
20302 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20303 
    if self.success is not None:
20304 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20305 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20306 
      for kiter485,viter486 in self.success.items():
20307 
        oprot.writeI64(kiter485)
20308 
        oprot.writeI64(viter486)
4018 chandransh 20309 
      oprot.writeMapEnd()
20310 
      oprot.writeFieldEnd()
20311 
    oprot.writeFieldStop()
20312 
    oprot.writeStructEnd()
20313 
 
20314 
  def validate(self):
20315 
    return
20316 
 
20317 
 
20318 
  def __repr__(self):
20319 
    L = ['%s=%r' % (key, value)
20320 
      for key, value in self.__dict__.iteritems()]
20321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20322 
 
20323 
  def __eq__(self, other):
20324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20325 
 
20326 
  def __ne__(self, other):
20327 
    return not (self == other)
4247 rajveer 20328 
 
4295 varun.gupt 20329 
class getOrdersForItemIds_args:
20330 
  """
20331 
  Attributes:
20332 
   - itemIds
20333 
  """
20334 
 
20335 
  thrift_spec = (
20336 
    None, # 0
20337 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20338 
  )
20339 
 
20340 
  def __init__(self, itemIds=None,):
20341 
    self.itemIds = itemIds
20342 
 
20343 
  def read(self, iprot):
20344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20346 
      return
20347 
    iprot.readStructBegin()
20348 
    while True:
20349 
      (fname, ftype, fid) = iprot.readFieldBegin()
20350 
      if ftype == TType.STOP:
20351 
        break
20352 
      if fid == 1:
20353 
        if ftype == TType.LIST:
20354 
          self.itemIds = []
6188 rajveer 20355 
          (_etype490, _size487) = iprot.readListBegin()
20356 
          for _i491 in xrange(_size487):
20357 
            _elem492 = iprot.readI64();
20358 
            self.itemIds.append(_elem492)
4295 varun.gupt 20359 
          iprot.readListEnd()
20360 
        else:
20361 
          iprot.skip(ftype)
20362 
      else:
20363 
        iprot.skip(ftype)
20364 
      iprot.readFieldEnd()
20365 
    iprot.readStructEnd()
20366 
 
20367 
  def write(self, oprot):
20368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20370 
      return
20371 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20372 
    if self.itemIds is not None:
20373 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20374 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20375 
      for iter493 in self.itemIds:
20376 
        oprot.writeI64(iter493)
4295 varun.gupt 20377 
      oprot.writeListEnd()
20378 
      oprot.writeFieldEnd()
20379 
    oprot.writeFieldStop()
20380 
    oprot.writeStructEnd()
20381 
 
20382 
  def validate(self):
20383 
    return
20384 
 
20385 
 
20386 
  def __repr__(self):
20387 
    L = ['%s=%r' % (key, value)
20388 
      for key, value in self.__dict__.iteritems()]
20389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20390 
 
20391 
  def __eq__(self, other):
20392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20393 
 
20394 
  def __ne__(self, other):
20395 
    return not (self == other)
20396 
 
20397 
class getOrdersForItemIds_result:
20398 
  """
20399 
  Attributes:
20400 
   - success
20401 
  """
20402 
 
20403 
  thrift_spec = (
20404 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20405 
  )
20406 
 
20407 
  def __init__(self, success=None,):
20408 
    self.success = success
20409 
 
20410 
  def read(self, iprot):
20411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20413 
      return
20414 
    iprot.readStructBegin()
20415 
    while True:
20416 
      (fname, ftype, fid) = iprot.readFieldBegin()
20417 
      if ftype == TType.STOP:
20418 
        break
20419 
      if fid == 0:
20420 
        if ftype == TType.LIST:
20421 
          self.success = []
6188 rajveer 20422 
          (_etype497, _size494) = iprot.readListBegin()
20423 
          for _i498 in xrange(_size494):
20424 
            _elem499 = Order()
20425 
            _elem499.read(iprot)
20426 
            self.success.append(_elem499)
4295 varun.gupt 20427 
          iprot.readListEnd()
20428 
        else:
20429 
          iprot.skip(ftype)
20430 
      else:
20431 
        iprot.skip(ftype)
20432 
      iprot.readFieldEnd()
20433 
    iprot.readStructEnd()
20434 
 
20435 
  def write(self, oprot):
20436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20438 
      return
20439 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20440 
    if self.success is not None:
20441 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20442 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20443 
      for iter500 in self.success:
20444 
        iter500.write(oprot)
4295 varun.gupt 20445 
      oprot.writeListEnd()
20446 
      oprot.writeFieldEnd()
20447 
    oprot.writeFieldStop()
20448 
    oprot.writeStructEnd()
20449 
 
20450 
  def validate(self):
20451 
    return
20452 
 
20453 
 
20454 
  def __repr__(self):
20455 
    L = ['%s=%r' % (key, value)
20456 
      for key, value in self.__dict__.iteritems()]
20457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20458 
 
20459 
  def __eq__(self, other):
20460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20461 
 
20462 
  def __ne__(self, other):
20463 
    return not (self == other)
20464 
 
4247 rajveer 20465 
class markOrderCancellationRequestReceived_args:
20466 
  """
20467 
  Attributes:
20468 
   - orderId
20469 
  """
20470 
 
20471 
  thrift_spec = (
20472 
    None, # 0
20473 
    (1, TType.I64, 'orderId', None, None, ), # 1
20474 
  )
20475 
 
20476 
  def __init__(self, orderId=None,):
20477 
    self.orderId = orderId
20478 
 
20479 
  def read(self, iprot):
20480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20482 
      return
20483 
    iprot.readStructBegin()
20484 
    while True:
20485 
      (fname, ftype, fid) = iprot.readFieldBegin()
20486 
      if ftype == TType.STOP:
20487 
        break
20488 
      if fid == 1:
20489 
        if ftype == TType.I64:
20490 
          self.orderId = iprot.readI64();
20491 
        else:
20492 
          iprot.skip(ftype)
20493 
      else:
20494 
        iprot.skip(ftype)
20495 
      iprot.readFieldEnd()
20496 
    iprot.readStructEnd()
20497 
 
20498 
  def write(self, oprot):
20499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20501 
      return
20502 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20503 
    if self.orderId is not None:
20504 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20505 
      oprot.writeI64(self.orderId)
20506 
      oprot.writeFieldEnd()
20507 
    oprot.writeFieldStop()
20508 
    oprot.writeStructEnd()
20509 
 
20510 
  def validate(self):
20511 
    return
20512 
 
20513 
 
20514 
  def __repr__(self):
20515 
    L = ['%s=%r' % (key, value)
20516 
      for key, value in self.__dict__.iteritems()]
20517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20518 
 
20519 
  def __eq__(self, other):
20520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20521 
 
20522 
  def __ne__(self, other):
20523 
    return not (self == other)
20524 
 
20525 
class markOrderCancellationRequestReceived_result:
20526 
  """
20527 
  Attributes:
20528 
   - ex
20529 
  """
20530 
 
20531 
  thrift_spec = (
20532 
    None, # 0
20533 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20534 
  )
20535 
 
20536 
  def __init__(self, ex=None,):
20537 
    self.ex = ex
20538 
 
20539 
  def read(self, iprot):
20540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20542 
      return
20543 
    iprot.readStructBegin()
20544 
    while True:
20545 
      (fname, ftype, fid) = iprot.readFieldBegin()
20546 
      if ftype == TType.STOP:
20547 
        break
20548 
      if fid == 1:
20549 
        if ftype == TType.STRUCT:
20550 
          self.ex = TransactionServiceException()
20551 
          self.ex.read(iprot)
20552 
        else:
20553 
          iprot.skip(ftype)
20554 
      else:
20555 
        iprot.skip(ftype)
20556 
      iprot.readFieldEnd()
20557 
    iprot.readStructEnd()
20558 
 
20559 
  def write(self, oprot):
20560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20562 
      return
20563 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20564 
    if self.ex is not None:
20565 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20566 
      self.ex.write(oprot)
20567 
      oprot.writeFieldEnd()
20568 
    oprot.writeFieldStop()
20569 
    oprot.writeStructEnd()
20570 
 
20571 
  def validate(self):
20572 
    return
20573 
 
20574 
 
20575 
  def __repr__(self):
20576 
    L = ['%s=%r' % (key, value)
20577 
      for key, value in self.__dict__.iteritems()]
20578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20579 
 
20580 
  def __eq__(self, other):
20581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20582 
 
20583 
  def __ne__(self, other):
20584 
    return not (self == other)
20585 
 
20586 
class markOrderCancellationRequestConfirmed_args:
20587 
  """
20588 
  Attributes:
20589 
   - orderId
20590 
  """
20591 
 
20592 
  thrift_spec = (
20593 
    None, # 0
20594 
    (1, TType.I64, 'orderId', None, None, ), # 1
20595 
  )
20596 
 
20597 
  def __init__(self, orderId=None,):
20598 
    self.orderId = orderId
20599 
 
20600 
  def read(self, iprot):
20601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20603 
      return
20604 
    iprot.readStructBegin()
20605 
    while True:
20606 
      (fname, ftype, fid) = iprot.readFieldBegin()
20607 
      if ftype == TType.STOP:
20608 
        break
20609 
      if fid == 1:
20610 
        if ftype == TType.I64:
20611 
          self.orderId = iprot.readI64();
20612 
        else:
20613 
          iprot.skip(ftype)
20614 
      else:
20615 
        iprot.skip(ftype)
20616 
      iprot.readFieldEnd()
20617 
    iprot.readStructEnd()
20618 
 
20619 
  def write(self, oprot):
20620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20622 
      return
20623 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20624 
    if self.orderId is not None:
20625 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20626 
      oprot.writeI64(self.orderId)
20627 
      oprot.writeFieldEnd()
20628 
    oprot.writeFieldStop()
20629 
    oprot.writeStructEnd()
20630 
 
20631 
  def validate(self):
20632 
    return
20633 
 
20634 
 
20635 
  def __repr__(self):
20636 
    L = ['%s=%r' % (key, value)
20637 
      for key, value in self.__dict__.iteritems()]
20638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20639 
 
20640 
  def __eq__(self, other):
20641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20642 
 
20643 
  def __ne__(self, other):
20644 
    return not (self == other)
20645 
 
20646 
class markOrderCancellationRequestConfirmed_result:
20647 
  """
20648 
  Attributes:
20649 
   - ex
20650 
  """
20651 
 
20652 
  thrift_spec = (
20653 
    None, # 0
20654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20655 
  )
20656 
 
20657 
  def __init__(self, ex=None,):
20658 
    self.ex = ex
20659 
 
20660 
  def read(self, iprot):
20661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20663 
      return
20664 
    iprot.readStructBegin()
20665 
    while True:
20666 
      (fname, ftype, fid) = iprot.readFieldBegin()
20667 
      if ftype == TType.STOP:
20668 
        break
20669 
      if fid == 1:
20670 
        if ftype == TType.STRUCT:
20671 
          self.ex = TransactionServiceException()
20672 
          self.ex.read(iprot)
20673 
        else:
20674 
          iprot.skip(ftype)
20675 
      else:
20676 
        iprot.skip(ftype)
20677 
      iprot.readFieldEnd()
20678 
    iprot.readStructEnd()
20679 
 
20680 
  def write(self, oprot):
20681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20683 
      return
20684 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20685 
    if self.ex is not None:
20686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20687 
      self.ex.write(oprot)
20688 
      oprot.writeFieldEnd()
20689 
    oprot.writeFieldStop()
20690 
    oprot.writeStructEnd()
20691 
 
20692 
  def validate(self):
20693 
    return
20694 
 
20695 
 
20696 
  def __repr__(self):
20697 
    L = ['%s=%r' % (key, value)
20698 
      for key, value in self.__dict__.iteritems()]
20699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20700 
 
20701 
  def __eq__(self, other):
20702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20703 
 
20704 
  def __ne__(self, other):
20705 
    return not (self == other)
20706 
 
20707 
class markOrderCancellationRequestDenied_args:
20708 
  """
20709 
  Attributes:
20710 
   - orderId
20711 
  """
20712 
 
20713 
  thrift_spec = (
20714 
    None, # 0
20715 
    (1, TType.I64, 'orderId', None, None, ), # 1
20716 
  )
20717 
 
20718 
  def __init__(self, orderId=None,):
20719 
    self.orderId = orderId
20720 
 
20721 
  def read(self, iprot):
20722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20724 
      return
20725 
    iprot.readStructBegin()
20726 
    while True:
20727 
      (fname, ftype, fid) = iprot.readFieldBegin()
20728 
      if ftype == TType.STOP:
20729 
        break
20730 
      if fid == 1:
20731 
        if ftype == TType.I64:
20732 
          self.orderId = iprot.readI64();
20733 
        else:
20734 
          iprot.skip(ftype)
20735 
      else:
20736 
        iprot.skip(ftype)
20737 
      iprot.readFieldEnd()
20738 
    iprot.readStructEnd()
20739 
 
20740 
  def write(self, oprot):
20741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20743 
      return
20744 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20745 
    if self.orderId is not None:
20746 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20747 
      oprot.writeI64(self.orderId)
20748 
      oprot.writeFieldEnd()
20749 
    oprot.writeFieldStop()
20750 
    oprot.writeStructEnd()
20751 
 
20752 
  def validate(self):
20753 
    return
20754 
 
20755 
 
20756 
  def __repr__(self):
20757 
    L = ['%s=%r' % (key, value)
20758 
      for key, value in self.__dict__.iteritems()]
20759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20760 
 
20761 
  def __eq__(self, other):
20762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20763 
 
20764 
  def __ne__(self, other):
20765 
    return not (self == other)
20766 
 
20767 
class markOrderCancellationRequestDenied_result:
20768 
  """
20769 
  Attributes:
20770 
   - ex
20771 
  """
20772 
 
20773 
  thrift_spec = (
20774 
    None, # 0
20775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20776 
  )
20777 
 
20778 
  def __init__(self, ex=None,):
20779 
    self.ex = ex
20780 
 
20781 
  def read(self, iprot):
20782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20784 
      return
20785 
    iprot.readStructBegin()
20786 
    while True:
20787 
      (fname, ftype, fid) = iprot.readFieldBegin()
20788 
      if ftype == TType.STOP:
20789 
        break
20790 
      if fid == 1:
20791 
        if ftype == TType.STRUCT:
20792 
          self.ex = TransactionServiceException()
20793 
          self.ex.read(iprot)
20794 
        else:
20795 
          iprot.skip(ftype)
20796 
      else:
20797 
        iprot.skip(ftype)
20798 
      iprot.readFieldEnd()
20799 
    iprot.readStructEnd()
20800 
 
20801 
  def write(self, oprot):
20802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20804 
      return
20805 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20806 
    if self.ex is not None:
20807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20808 
      self.ex.write(oprot)
20809 
      oprot.writeFieldEnd()
20810 
    oprot.writeFieldStop()
20811 
    oprot.writeStructEnd()
20812 
 
20813 
  def validate(self):
20814 
    return
20815 
 
20816 
 
20817 
  def __repr__(self):
20818 
    L = ['%s=%r' % (key, value)
20819 
      for key, value in self.__dict__.iteritems()]
20820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20821 
 
20822 
  def __eq__(self, other):
20823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20824 
 
20825 
  def __ne__(self, other):
20826 
    return not (self == other)
20827 
 
4258 rajveer 20828 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20829 
  """
20830 
  Attributes:
4258 rajveer 20831 
   - transactionId
4247 rajveer 20832 
  """
20833 
 
20834 
  thrift_spec = (
20835 
    None, # 0
4258 rajveer 20836 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20837 
  )
20838 
 
4258 rajveer 20839 
  def __init__(self, transactionId=None,):
20840 
    self.transactionId = transactionId
4247 rajveer 20841 
 
20842 
  def read(self, iprot):
20843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20845 
      return
20846 
    iprot.readStructBegin()
20847 
    while True:
20848 
      (fname, ftype, fid) = iprot.readFieldBegin()
20849 
      if ftype == TType.STOP:
20850 
        break
20851 
      if fid == 1:
20852 
        if ftype == TType.I64:
4258 rajveer 20853 
          self.transactionId = iprot.readI64();
4247 rajveer 20854 
        else:
20855 
          iprot.skip(ftype)
20856 
      else:
20857 
        iprot.skip(ftype)
20858 
      iprot.readFieldEnd()
20859 
    iprot.readStructEnd()
20860 
 
20861 
  def write(self, oprot):
20862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20864 
      return
4258 rajveer 20865 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20866 
    if self.transactionId is not None:
20867 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20868 
      oprot.writeI64(self.transactionId)
4247 rajveer 20869 
      oprot.writeFieldEnd()
20870 
    oprot.writeFieldStop()
20871 
    oprot.writeStructEnd()
20872 
 
20873 
  def validate(self):
20874 
    return
20875 
 
20876 
 
20877 
  def __repr__(self):
20878 
    L = ['%s=%r' % (key, value)
20879 
      for key, value in self.__dict__.iteritems()]
20880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20881 
 
20882 
  def __eq__(self, other):
20883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20884 
 
20885 
  def __ne__(self, other):
20886 
    return not (self == other)
20887 
 
4258 rajveer 20888 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20889 
  """
20890 
  Attributes:
20891 
   - ex
20892 
  """
20893 
 
20894 
  thrift_spec = (
20895 
    None, # 0
20896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20897 
  )
20898 
 
20899 
  def __init__(self, ex=None,):
20900 
    self.ex = ex
20901 
 
20902 
  def read(self, iprot):
20903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20905 
      return
20906 
    iprot.readStructBegin()
20907 
    while True:
20908 
      (fname, ftype, fid) = iprot.readFieldBegin()
20909 
      if ftype == TType.STOP:
20910 
        break
20911 
      if fid == 1:
20912 
        if ftype == TType.STRUCT:
20913 
          self.ex = TransactionServiceException()
20914 
          self.ex.read(iprot)
20915 
        else:
20916 
          iprot.skip(ftype)
20917 
      else:
20918 
        iprot.skip(ftype)
20919 
      iprot.readFieldEnd()
20920 
    iprot.readStructEnd()
20921 
 
20922 
  def write(self, oprot):
20923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20925 
      return
4258 rajveer 20926 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20927 
    if self.ex is not None:
20928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20929 
      self.ex.write(oprot)
20930 
      oprot.writeFieldEnd()
20931 
    oprot.writeFieldStop()
20932 
    oprot.writeStructEnd()
20933 
 
20934 
  def validate(self):
20935 
    return
20936 
 
20937 
 
20938 
  def __repr__(self):
20939 
    L = ['%s=%r' % (key, value)
20940 
      for key, value in self.__dict__.iteritems()]
20941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20942 
 
20943 
  def __eq__(self, other):
20944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20945 
 
20946 
  def __ne__(self, other):
20947 
    return not (self == other)
4259 anupam.sin 20948 
 
20949 
class refundTransaction_args:
20950 
  """
20951 
  Attributes:
20952 
   - transactionId
20953 
   - refundedBy
20954 
   - reason
20955 
  """
20956 
 
20957 
  thrift_spec = (
20958 
    None, # 0
20959 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20960 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20961 
    (3, TType.STRING, 'reason', None, None, ), # 3
20962 
  )
20963 
 
20964 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20965 
    self.transactionId = transactionId
20966 
    self.refundedBy = refundedBy
20967 
    self.reason = reason
20968 
 
20969 
  def read(self, iprot):
20970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20972 
      return
20973 
    iprot.readStructBegin()
20974 
    while True:
20975 
      (fname, ftype, fid) = iprot.readFieldBegin()
20976 
      if ftype == TType.STOP:
20977 
        break
20978 
      if fid == 1:
20979 
        if ftype == TType.I64:
20980 
          self.transactionId = iprot.readI64();
20981 
        else:
20982 
          iprot.skip(ftype)
20983 
      elif fid == 2:
20984 
        if ftype == TType.STRING:
20985 
          self.refundedBy = iprot.readString();
20986 
        else:
20987 
          iprot.skip(ftype)
20988 
      elif fid == 3:
20989 
        if ftype == TType.STRING:
20990 
          self.reason = iprot.readString();
20991 
        else:
20992 
          iprot.skip(ftype)
20993 
      else:
20994 
        iprot.skip(ftype)
20995 
      iprot.readFieldEnd()
20996 
    iprot.readStructEnd()
20997 
 
20998 
  def write(self, oprot):
20999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21001 
      return
21002 
    oprot.writeStructBegin('refundTransaction_args')
21003 
    if self.transactionId is not None:
21004 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21005 
      oprot.writeI64(self.transactionId)
21006 
      oprot.writeFieldEnd()
21007 
    if self.refundedBy is not None:
21008 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21009 
      oprot.writeString(self.refundedBy)
21010 
      oprot.writeFieldEnd()
21011 
    if self.reason is not None:
21012 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21013 
      oprot.writeString(self.reason)
21014 
      oprot.writeFieldEnd()
21015 
    oprot.writeFieldStop()
21016 
    oprot.writeStructEnd()
21017 
 
21018 
  def validate(self):
21019 
    return
21020 
 
21021 
 
21022 
  def __repr__(self):
21023 
    L = ['%s=%r' % (key, value)
21024 
      for key, value in self.__dict__.iteritems()]
21025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21026 
 
21027 
  def __eq__(self, other):
21028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21029 
 
21030 
  def __ne__(self, other):
21031 
    return not (self == other)
21032 
 
21033 
class refundTransaction_result:
21034 
  """
21035 
  Attributes:
21036 
   - ex
21037 
  """
21038 
 
21039 
  thrift_spec = (
21040 
    None, # 0
21041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21042 
  )
21043 
 
21044 
  def __init__(self, ex=None,):
21045 
    self.ex = ex
21046 
 
21047 
  def read(self, iprot):
21048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21050 
      return
21051 
    iprot.readStructBegin()
21052 
    while True:
21053 
      (fname, ftype, fid) = iprot.readFieldBegin()
21054 
      if ftype == TType.STOP:
21055 
        break
21056 
      if fid == 1:
21057 
        if ftype == TType.STRUCT:
21058 
          self.ex = TransactionServiceException()
21059 
          self.ex.read(iprot)
21060 
        else:
21061 
          iprot.skip(ftype)
21062 
      else:
21063 
        iprot.skip(ftype)
21064 
      iprot.readFieldEnd()
21065 
    iprot.readStructEnd()
21066 
 
21067 
  def write(self, oprot):
21068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21070 
      return
21071 
    oprot.writeStructBegin('refundTransaction_result')
21072 
    if self.ex is not None:
21073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21074 
      self.ex.write(oprot)
21075 
      oprot.writeFieldEnd()
21076 
    oprot.writeFieldStop()
21077 
    oprot.writeStructEnd()
21078 
 
21079 
  def validate(self):
21080 
    return
21081 
 
21082 
 
21083 
  def __repr__(self):
21084 
    L = ['%s=%r' % (key, value)
21085 
      for key, value in self.__dict__.iteritems()]
21086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21087 
 
21088 
  def __eq__(self, other):
21089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21090 
 
21091 
  def __ne__(self, other):
21092 
    return not (self == other)
4285 rajveer 21093 
 
4324 mandeep.dh 21094 
class updateShipmentAddress_args:
21095 
  """
21096 
  Attributes:
21097 
   - orderId
21098 
   - addressId
21099 
  """
21100 
 
21101 
  thrift_spec = (
21102 
    None, # 0
21103 
    (1, TType.I64, 'orderId', None, None, ), # 1
21104 
    (2, TType.I64, 'addressId', None, None, ), # 2
21105 
  )
21106 
 
21107 
  def __init__(self, orderId=None, addressId=None,):
21108 
    self.orderId = orderId
21109 
    self.addressId = addressId
21110 
 
21111 
  def read(self, iprot):
21112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21114 
      return
21115 
    iprot.readStructBegin()
21116 
    while True:
21117 
      (fname, ftype, fid) = iprot.readFieldBegin()
21118 
      if ftype == TType.STOP:
21119 
        break
21120 
      if fid == 1:
21121 
        if ftype == TType.I64:
21122 
          self.orderId = iprot.readI64();
21123 
        else:
21124 
          iprot.skip(ftype)
21125 
      elif fid == 2:
21126 
        if ftype == TType.I64:
21127 
          self.addressId = iprot.readI64();
21128 
        else:
21129 
          iprot.skip(ftype)
21130 
      else:
21131 
        iprot.skip(ftype)
21132 
      iprot.readFieldEnd()
21133 
    iprot.readStructEnd()
21134 
 
21135 
  def write(self, oprot):
21136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21138 
      return
21139 
    oprot.writeStructBegin('updateShipmentAddress_args')
21140 
    if self.orderId is not None:
21141 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21142 
      oprot.writeI64(self.orderId)
21143 
      oprot.writeFieldEnd()
21144 
    if self.addressId is not None:
21145 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21146 
      oprot.writeI64(self.addressId)
21147 
      oprot.writeFieldEnd()
21148 
    oprot.writeFieldStop()
21149 
    oprot.writeStructEnd()
21150 
 
21151 
  def validate(self):
21152 
    return
21153 
 
21154 
 
21155 
  def __repr__(self):
21156 
    L = ['%s=%r' % (key, value)
21157 
      for key, value in self.__dict__.iteritems()]
21158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21159 
 
21160 
  def __eq__(self, other):
21161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21162 
 
21163 
  def __ne__(self, other):
21164 
    return not (self == other)
21165 
 
21166 
class updateShipmentAddress_result:
21167 
  """
21168 
  Attributes:
21169 
   - ex
21170 
  """
21171 
 
21172 
  thrift_spec = (
21173 
    None, # 0
21174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21175 
  )
21176 
 
21177 
  def __init__(self, ex=None,):
21178 
    self.ex = ex
21179 
 
21180 
  def read(self, iprot):
21181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21183 
      return
21184 
    iprot.readStructBegin()
21185 
    while True:
21186 
      (fname, ftype, fid) = iprot.readFieldBegin()
21187 
      if ftype == TType.STOP:
21188 
        break
21189 
      if fid == 1:
21190 
        if ftype == TType.STRUCT:
21191 
          self.ex = TransactionServiceException()
21192 
          self.ex.read(iprot)
21193 
        else:
21194 
          iprot.skip(ftype)
21195 
      else:
21196 
        iprot.skip(ftype)
21197 
      iprot.readFieldEnd()
21198 
    iprot.readStructEnd()
21199 
 
21200 
  def write(self, oprot):
21201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21203 
      return
21204 
    oprot.writeStructBegin('updateShipmentAddress_result')
21205 
    if self.ex is not None:
21206 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21207 
      self.ex.write(oprot)
21208 
      oprot.writeFieldEnd()
21209 
    oprot.writeFieldStop()
21210 
    oprot.writeStructEnd()
21211 
 
21212 
  def validate(self):
21213 
    return
21214 
 
21215 
 
21216 
  def __repr__(self):
21217 
    L = ['%s=%r' % (key, value)
21218 
      for key, value in self.__dict__.iteritems()]
21219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21220 
 
21221 
  def __eq__(self, other):
21222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21223 
 
21224 
  def __ne__(self, other):
21225 
    return not (self == other)
21226 
 
4285 rajveer 21227 
class acceptOrdersForItemId_args:
21228 
  """
21229 
  Attributes:
21230 
   - itemId
21231 
   - inventory
21232 
  """
21233 
 
21234 
  thrift_spec = (
21235 
    None, # 0
21236 
    (1, TType.I64, 'itemId', None, None, ), # 1
21237 
    (2, TType.I64, 'inventory', None, None, ), # 2
21238 
  )
21239 
 
21240 
  def __init__(self, itemId=None, inventory=None,):
21241 
    self.itemId = itemId
21242 
    self.inventory = inventory
21243 
 
21244 
  def read(self, iprot):
21245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21247 
      return
21248 
    iprot.readStructBegin()
21249 
    while True:
21250 
      (fname, ftype, fid) = iprot.readFieldBegin()
21251 
      if ftype == TType.STOP:
21252 
        break
21253 
      if fid == 1:
21254 
        if ftype == TType.I64:
21255 
          self.itemId = iprot.readI64();
21256 
        else:
21257 
          iprot.skip(ftype)
21258 
      elif fid == 2:
21259 
        if ftype == TType.I64:
21260 
          self.inventory = iprot.readI64();
21261 
        else:
21262 
          iprot.skip(ftype)
21263 
      else:
21264 
        iprot.skip(ftype)
21265 
      iprot.readFieldEnd()
21266 
    iprot.readStructEnd()
21267 
 
21268 
  def write(self, oprot):
21269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21271 
      return
21272 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21273 
    if self.itemId is not None:
21274 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21275 
      oprot.writeI64(self.itemId)
21276 
      oprot.writeFieldEnd()
21277 
    if self.inventory is not None:
21278 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21279 
      oprot.writeI64(self.inventory)
21280 
      oprot.writeFieldEnd()
21281 
    oprot.writeFieldStop()
21282 
    oprot.writeStructEnd()
21283 
 
21284 
  def validate(self):
21285 
    return
21286 
 
21287 
 
21288 
  def __repr__(self):
21289 
    L = ['%s=%r' % (key, value)
21290 
      for key, value in self.__dict__.iteritems()]
21291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21292 
 
21293 
  def __eq__(self, other):
21294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21295 
 
21296 
  def __ne__(self, other):
21297 
    return not (self == other)
21298 
 
21299 
class acceptOrdersForItemId_result:
21300 
  """
21301 
  Attributes:
21302 
   - success
21303 
   - ex
21304 
  """
21305 
 
21306 
  thrift_spec = (
21307 
    (0, TType.BOOL, 'success', None, None, ), # 0
21308 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21309 
  )
21310 
 
21311 
  def __init__(self, success=None, ex=None,):
21312 
    self.success = success
21313 
    self.ex = ex
21314 
 
21315 
  def read(self, iprot):
21316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21318 
      return
21319 
    iprot.readStructBegin()
21320 
    while True:
21321 
      (fname, ftype, fid) = iprot.readFieldBegin()
21322 
      if ftype == TType.STOP:
21323 
        break
21324 
      if fid == 0:
21325 
        if ftype == TType.BOOL:
21326 
          self.success = iprot.readBool();
21327 
        else:
21328 
          iprot.skip(ftype)
21329 
      elif fid == 1:
21330 
        if ftype == TType.STRUCT:
21331 
          self.ex = TransactionServiceException()
21332 
          self.ex.read(iprot)
21333 
        else:
21334 
          iprot.skip(ftype)
21335 
      else:
21336 
        iprot.skip(ftype)
21337 
      iprot.readFieldEnd()
21338 
    iprot.readStructEnd()
21339 
 
21340 
  def write(self, oprot):
21341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21343 
      return
21344 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21345 
    if self.success is not None:
21346 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21347 
      oprot.writeBool(self.success)
21348 
      oprot.writeFieldEnd()
21349 
    if self.ex is not None:
21350 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21351 
      self.ex.write(oprot)
21352 
      oprot.writeFieldEnd()
21353 
    oprot.writeFieldStop()
21354 
    oprot.writeStructEnd()
21355 
 
21356 
  def validate(self):
21357 
    return
21358 
 
21359 
 
21360 
  def __repr__(self):
21361 
    L = ['%s=%r' % (key, value)
21362 
      for key, value in self.__dict__.iteritems()]
21363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21364 
 
21365 
  def __eq__(self, other):
21366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21367 
 
21368 
  def __ne__(self, other):
21369 
    return not (self == other)
4303 rajveer 21370 
 
21371 
class markOrdersAsPORaised_args:
21372 
  """
21373 
  Attributes:
21374 
   - vendorId
21375 
   - itemId
21376 
   - quantity
21377 
   - estimate
4369 rajveer 21378 
   - isReminder
4303 rajveer 21379 
  """
21380 
 
21381 
  thrift_spec = (
21382 
    None, # 0
21383 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21384 
    (2, TType.I64, 'itemId', None, None, ), # 2
21385 
    (3, TType.I64, 'quantity', None, None, ), # 3
21386 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21387 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21388 
  )
21389 
 
4369 rajveer 21390 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21391 
    self.vendorId = vendorId
21392 
    self.itemId = itemId
21393 
    self.quantity = quantity
21394 
    self.estimate = estimate
4369 rajveer 21395 
    self.isReminder = isReminder
4303 rajveer 21396 
 
21397 
  def read(self, iprot):
21398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21400 
      return
21401 
    iprot.readStructBegin()
21402 
    while True:
21403 
      (fname, ftype, fid) = iprot.readFieldBegin()
21404 
      if ftype == TType.STOP:
21405 
        break
21406 
      if fid == 1:
21407 
        if ftype == TType.I64:
21408 
          self.vendorId = iprot.readI64();
21409 
        else:
21410 
          iprot.skip(ftype)
21411 
      elif fid == 2:
21412 
        if ftype == TType.I64:
21413 
          self.itemId = iprot.readI64();
21414 
        else:
21415 
          iprot.skip(ftype)
21416 
      elif fid == 3:
21417 
        if ftype == TType.I64:
21418 
          self.quantity = iprot.readI64();
21419 
        else:
21420 
          iprot.skip(ftype)
21421 
      elif fid == 4:
21422 
        if ftype == TType.I64:
21423 
          self.estimate = iprot.readI64();
21424 
        else:
21425 
          iprot.skip(ftype)
4369 rajveer 21426 
      elif fid == 5:
21427 
        if ftype == TType.BOOL:
21428 
          self.isReminder = iprot.readBool();
21429 
        else:
21430 
          iprot.skip(ftype)
4303 rajveer 21431 
      else:
21432 
        iprot.skip(ftype)
21433 
      iprot.readFieldEnd()
21434 
    iprot.readStructEnd()
21435 
 
21436 
  def write(self, oprot):
21437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21439 
      return
21440 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21441 
    if self.vendorId is not None:
21442 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21443 
      oprot.writeI64(self.vendorId)
21444 
      oprot.writeFieldEnd()
21445 
    if self.itemId is not None:
21446 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21447 
      oprot.writeI64(self.itemId)
21448 
      oprot.writeFieldEnd()
21449 
    if self.quantity is not None:
21450 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21451 
      oprot.writeI64(self.quantity)
21452 
      oprot.writeFieldEnd()
21453 
    if self.estimate is not None:
21454 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21455 
      oprot.writeI64(self.estimate)
21456 
      oprot.writeFieldEnd()
4369 rajveer 21457 
    if self.isReminder is not None:
21458 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21459 
      oprot.writeBool(self.isReminder)
21460 
      oprot.writeFieldEnd()
4303 rajveer 21461 
    oprot.writeFieldStop()
21462 
    oprot.writeStructEnd()
21463 
 
21464 
  def validate(self):
21465 
    return
21466 
 
21467 
 
21468 
  def __repr__(self):
21469 
    L = ['%s=%r' % (key, value)
21470 
      for key, value in self.__dict__.iteritems()]
21471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21472 
 
21473 
  def __eq__(self, other):
21474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21475 
 
21476 
  def __ne__(self, other):
21477 
    return not (self == other)
21478 
 
21479 
class markOrdersAsPORaised_result:
21480 
  """
21481 
  Attributes:
21482 
   - ex
21483 
  """
21484 
 
21485 
  thrift_spec = (
21486 
    None, # 0
21487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21488 
  )
21489 
 
21490 
  def __init__(self, ex=None,):
21491 
    self.ex = ex
21492 
 
21493 
  def read(self, iprot):
21494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21496 
      return
21497 
    iprot.readStructBegin()
21498 
    while True:
21499 
      (fname, ftype, fid) = iprot.readFieldBegin()
21500 
      if ftype == TType.STOP:
21501 
        break
21502 
      if fid == 1:
21503 
        if ftype == TType.STRUCT:
21504 
          self.ex = TransactionServiceException()
21505 
          self.ex.read(iprot)
21506 
        else:
21507 
          iprot.skip(ftype)
21508 
      else:
21509 
        iprot.skip(ftype)
21510 
      iprot.readFieldEnd()
21511 
    iprot.readStructEnd()
21512 
 
21513 
  def write(self, oprot):
21514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21516 
      return
21517 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21518 
    if self.ex is not None:
21519 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21520 
      self.ex.write(oprot)
21521 
      oprot.writeFieldEnd()
21522 
    oprot.writeFieldStop()
21523 
    oprot.writeStructEnd()
21524 
 
21525 
  def validate(self):
21526 
    return
21527 
 
21528 
 
21529 
  def __repr__(self):
21530 
    L = ['%s=%r' % (key, value)
21531 
      for key, value in self.__dict__.iteritems()]
21532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21533 
 
21534 
  def __eq__(self, other):
21535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21536 
 
21537 
  def __ne__(self, other):
21538 
    return not (self == other)
21539 
 
21540 
class markOrdersAsReversalInitiated_args:
21541 
  """
21542 
  Attributes:
21543 
   - vendorId
21544 
   - itemId
21545 
   - quantity
21546 
   - estimate
4369 rajveer 21547 
   - isReminder
4303 rajveer 21548 
  """
21549 
 
21550 
  thrift_spec = (
21551 
    None, # 0
21552 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21553 
    (2, TType.I64, 'itemId', None, None, ), # 2
21554 
    (3, TType.I64, 'quantity', None, None, ), # 3
21555 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21556 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21557 
  )
21558 
 
4369 rajveer 21559 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21560 
    self.vendorId = vendorId
21561 
    self.itemId = itemId
21562 
    self.quantity = quantity
21563 
    self.estimate = estimate
4369 rajveer 21564 
    self.isReminder = isReminder
4303 rajveer 21565 
 
21566 
  def read(self, iprot):
21567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21569 
      return
21570 
    iprot.readStructBegin()
21571 
    while True:
21572 
      (fname, ftype, fid) = iprot.readFieldBegin()
21573 
      if ftype == TType.STOP:
21574 
        break
21575 
      if fid == 1:
21576 
        if ftype == TType.I64:
21577 
          self.vendorId = iprot.readI64();
21578 
        else:
21579 
          iprot.skip(ftype)
21580 
      elif fid == 2:
21581 
        if ftype == TType.I64:
21582 
          self.itemId = iprot.readI64();
21583 
        else:
21584 
          iprot.skip(ftype)
21585 
      elif fid == 3:
21586 
        if ftype == TType.I64:
21587 
          self.quantity = iprot.readI64();
21588 
        else:
21589 
          iprot.skip(ftype)
21590 
      elif fid == 4:
21591 
        if ftype == TType.I64:
21592 
          self.estimate = iprot.readI64();
21593 
        else:
21594 
          iprot.skip(ftype)
4369 rajveer 21595 
      elif fid == 5:
21596 
        if ftype == TType.BOOL:
21597 
          self.isReminder = iprot.readBool();
21598 
        else:
21599 
          iprot.skip(ftype)
4303 rajveer 21600 
      else:
21601 
        iprot.skip(ftype)
21602 
      iprot.readFieldEnd()
21603 
    iprot.readStructEnd()
21604 
 
21605 
  def write(self, oprot):
21606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21608 
      return
21609 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21610 
    if self.vendorId is not None:
21611 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21612 
      oprot.writeI64(self.vendorId)
21613 
      oprot.writeFieldEnd()
21614 
    if self.itemId is not None:
21615 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21616 
      oprot.writeI64(self.itemId)
21617 
      oprot.writeFieldEnd()
21618 
    if self.quantity is not None:
21619 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21620 
      oprot.writeI64(self.quantity)
21621 
      oprot.writeFieldEnd()
21622 
    if self.estimate is not None:
21623 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21624 
      oprot.writeI64(self.estimate)
21625 
      oprot.writeFieldEnd()
4369 rajveer 21626 
    if self.isReminder is not None:
21627 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21628 
      oprot.writeBool(self.isReminder)
21629 
      oprot.writeFieldEnd()
4303 rajveer 21630 
    oprot.writeFieldStop()
21631 
    oprot.writeStructEnd()
21632 
 
21633 
  def validate(self):
21634 
    return
21635 
 
21636 
 
21637 
  def __repr__(self):
21638 
    L = ['%s=%r' % (key, value)
21639 
      for key, value in self.__dict__.iteritems()]
21640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21641 
 
21642 
  def __eq__(self, other):
21643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21644 
 
21645 
  def __ne__(self, other):
21646 
    return not (self == other)
21647 
 
21648 
class markOrdersAsReversalInitiated_result:
21649 
  """
21650 
  Attributes:
21651 
   - ex
21652 
  """
21653 
 
21654 
  thrift_spec = (
21655 
    None, # 0
21656 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21657 
  )
21658 
 
21659 
  def __init__(self, ex=None,):
21660 
    self.ex = ex
21661 
 
21662 
  def read(self, iprot):
21663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21665 
      return
21666 
    iprot.readStructBegin()
21667 
    while True:
21668 
      (fname, ftype, fid) = iprot.readFieldBegin()
21669 
      if ftype == TType.STOP:
21670 
        break
21671 
      if fid == 1:
21672 
        if ftype == TType.STRUCT:
21673 
          self.ex = TransactionServiceException()
21674 
          self.ex.read(iprot)
21675 
        else:
21676 
          iprot.skip(ftype)
21677 
      else:
21678 
        iprot.skip(ftype)
21679 
      iprot.readFieldEnd()
21680 
    iprot.readStructEnd()
21681 
 
21682 
  def write(self, oprot):
21683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21685 
      return
21686 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21687 
    if self.ex is not None:
21688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21689 
      self.ex.write(oprot)
21690 
      oprot.writeFieldEnd()
21691 
    oprot.writeFieldStop()
21692 
    oprot.writeStructEnd()
21693 
 
21694 
  def validate(self):
21695 
    return
21696 
 
21697 
 
21698 
  def __repr__(self):
21699 
    L = ['%s=%r' % (key, value)
21700 
      for key, value in self.__dict__.iteritems()]
21701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21702 
 
21703 
  def __eq__(self, other):
21704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21705 
 
21706 
  def __ne__(self, other):
21707 
    return not (self == other)
21708 
 
21709 
class markOrdersAsNotAvailabke_args:
21710 
  """
21711 
  Attributes:
21712 
   - vendorId
21713 
   - itemId
21714 
   - quantity
21715 
   - estimate
4369 rajveer 21716 
   - isReminder
4303 rajveer 21717 
  """
21718 
 
21719 
  thrift_spec = (
21720 
    None, # 0
21721 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21722 
    (2, TType.I64, 'itemId', None, None, ), # 2
21723 
    (3, TType.I64, 'quantity', None, None, ), # 3
21724 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21725 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21726 
  )
21727 
 
4369 rajveer 21728 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21729 
    self.vendorId = vendorId
21730 
    self.itemId = itemId
21731 
    self.quantity = quantity
21732 
    self.estimate = estimate
4369 rajveer 21733 
    self.isReminder = isReminder
4303 rajveer 21734 
 
21735 
  def read(self, iprot):
21736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21738 
      return
21739 
    iprot.readStructBegin()
21740 
    while True:
21741 
      (fname, ftype, fid) = iprot.readFieldBegin()
21742 
      if ftype == TType.STOP:
21743 
        break
21744 
      if fid == 1:
21745 
        if ftype == TType.I64:
21746 
          self.vendorId = iprot.readI64();
21747 
        else:
21748 
          iprot.skip(ftype)
21749 
      elif fid == 2:
21750 
        if ftype == TType.I64:
21751 
          self.itemId = iprot.readI64();
21752 
        else:
21753 
          iprot.skip(ftype)
21754 
      elif fid == 3:
21755 
        if ftype == TType.I64:
21756 
          self.quantity = iprot.readI64();
21757 
        else:
21758 
          iprot.skip(ftype)
21759 
      elif fid == 4:
21760 
        if ftype == TType.I64:
21761 
          self.estimate = iprot.readI64();
21762 
        else:
21763 
          iprot.skip(ftype)
4369 rajveer 21764 
      elif fid == 5:
21765 
        if ftype == TType.BOOL:
21766 
          self.isReminder = iprot.readBool();
21767 
        else:
21768 
          iprot.skip(ftype)
4303 rajveer 21769 
      else:
21770 
        iprot.skip(ftype)
21771 
      iprot.readFieldEnd()
21772 
    iprot.readStructEnd()
21773 
 
21774 
  def write(self, oprot):
21775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21777 
      return
21778 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21779 
    if self.vendorId is not None:
21780 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21781 
      oprot.writeI64(self.vendorId)
21782 
      oprot.writeFieldEnd()
21783 
    if self.itemId is not None:
21784 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21785 
      oprot.writeI64(self.itemId)
21786 
      oprot.writeFieldEnd()
21787 
    if self.quantity is not None:
21788 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21789 
      oprot.writeI64(self.quantity)
21790 
      oprot.writeFieldEnd()
21791 
    if self.estimate is not None:
21792 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21793 
      oprot.writeI64(self.estimate)
21794 
      oprot.writeFieldEnd()
4369 rajveer 21795 
    if self.isReminder is not None:
21796 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21797 
      oprot.writeBool(self.isReminder)
21798 
      oprot.writeFieldEnd()
4303 rajveer 21799 
    oprot.writeFieldStop()
21800 
    oprot.writeStructEnd()
21801 
 
21802 
  def validate(self):
21803 
    return
21804 
 
21805 
 
21806 
  def __repr__(self):
21807 
    L = ['%s=%r' % (key, value)
21808 
      for key, value in self.__dict__.iteritems()]
21809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21810 
 
21811 
  def __eq__(self, other):
21812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21813 
 
21814 
  def __ne__(self, other):
21815 
    return not (self == other)
21816 
 
21817 
class markOrdersAsNotAvailabke_result:
21818 
  """
21819 
  Attributes:
21820 
   - ex
21821 
  """
21822 
 
21823 
  thrift_spec = (
21824 
    None, # 0
21825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21826 
  )
21827 
 
21828 
  def __init__(self, ex=None,):
21829 
    self.ex = ex
21830 
 
21831 
  def read(self, iprot):
21832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21834 
      return
21835 
    iprot.readStructBegin()
21836 
    while True:
21837 
      (fname, ftype, fid) = iprot.readFieldBegin()
21838 
      if ftype == TType.STOP:
21839 
        break
21840 
      if fid == 1:
21841 
        if ftype == TType.STRUCT:
21842 
          self.ex = TransactionServiceException()
21843 
          self.ex.read(iprot)
21844 
        else:
21845 
          iprot.skip(ftype)
21846 
      else:
21847 
        iprot.skip(ftype)
21848 
      iprot.readFieldEnd()
21849 
    iprot.readStructEnd()
21850 
 
21851 
  def write(self, oprot):
21852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21854 
      return
21855 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21856 
    if self.ex is not None:
21857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21858 
      self.ex.write(oprot)
21859 
      oprot.writeFieldEnd()
21860 
    oprot.writeFieldStop()
21861 
    oprot.writeStructEnd()
21862 
 
21863 
  def validate(self):
21864 
    return
21865 
 
21866 
 
21867 
  def __repr__(self):
21868 
    L = ['%s=%r' % (key, value)
21869 
      for key, value in self.__dict__.iteritems()]
21870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21871 
 
21872 
  def __eq__(self, other):
21873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21874 
 
21875 
  def __ne__(self, other):
21876 
    return not (self == other)
4369 rajveer 21877 
 
21878 
class markOrdersAsTimeout_args:
21879 
  """
21880 
  Attributes:
21881 
   - vendorId
21882 
  """
21883 
 
21884 
  thrift_spec = (
21885 
    None, # 0
21886 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21887 
  )
21888 
 
21889 
  def __init__(self, vendorId=None,):
21890 
    self.vendorId = vendorId
21891 
 
21892 
  def read(self, iprot):
21893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21895 
      return
21896 
    iprot.readStructBegin()
21897 
    while True:
21898 
      (fname, ftype, fid) = iprot.readFieldBegin()
21899 
      if ftype == TType.STOP:
21900 
        break
21901 
      if fid == 1:
21902 
        if ftype == TType.I64:
21903 
          self.vendorId = iprot.readI64();
21904 
        else:
21905 
          iprot.skip(ftype)
21906 
      else:
21907 
        iprot.skip(ftype)
21908 
      iprot.readFieldEnd()
21909 
    iprot.readStructEnd()
21910 
 
21911 
  def write(self, oprot):
21912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21914 
      return
21915 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21916 
    if self.vendorId is not None:
21917 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21918 
      oprot.writeI64(self.vendorId)
21919 
      oprot.writeFieldEnd()
21920 
    oprot.writeFieldStop()
21921 
    oprot.writeStructEnd()
21922 
 
21923 
  def validate(self):
21924 
    return
21925 
 
21926 
 
21927 
  def __repr__(self):
21928 
    L = ['%s=%r' % (key, value)
21929 
      for key, value in self.__dict__.iteritems()]
21930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21931 
 
21932 
  def __eq__(self, other):
21933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21934 
 
21935 
  def __ne__(self, other):
21936 
    return not (self == other)
21937 
 
21938 
class markOrdersAsTimeout_result:
21939 
  """
21940 
  Attributes:
21941 
   - success
21942 
   - ex
21943 
  """
21944 
 
21945 
  thrift_spec = (
21946 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21948 
  )
21949 
 
21950 
  def __init__(self, success=None, ex=None,):
21951 
    self.success = success
21952 
    self.ex = ex
21953 
 
21954 
  def read(self, iprot):
21955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21957 
      return
21958 
    iprot.readStructBegin()
21959 
    while True:
21960 
      (fname, ftype, fid) = iprot.readFieldBegin()
21961 
      if ftype == TType.STOP:
21962 
        break
21963 
      if fid == 0:
21964 
        if ftype == TType.MAP:
21965 
          self.success = {}
6188 rajveer 21966 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21967 
          for _i505 in xrange(_size501):
21968 
            _key506 = iprot.readI32();
21969 
            _val507 = TimeoutSummary()
21970 
            _val507.read(iprot)
21971 
            self.success[_key506] = _val507
4369 rajveer 21972 
          iprot.readMapEnd()
21973 
        else:
21974 
          iprot.skip(ftype)
21975 
      elif fid == 1:
21976 
        if ftype == TType.STRUCT:
21977 
          self.ex = TransactionServiceException()
21978 
          self.ex.read(iprot)
21979 
        else:
21980 
          iprot.skip(ftype)
21981 
      else:
21982 
        iprot.skip(ftype)
21983 
      iprot.readFieldEnd()
21984 
    iprot.readStructEnd()
21985 
 
21986 
  def write(self, oprot):
21987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21989 
      return
21990 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21991 
    if self.success is not None:
21992 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21993 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21994 
      for kiter508,viter509 in self.success.items():
21995 
        oprot.writeI32(kiter508)
21996 
        viter509.write(oprot)
4369 rajveer 21997 
      oprot.writeMapEnd()
21998 
      oprot.writeFieldEnd()
21999 
    if self.ex is not None:
22000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22001 
      self.ex.write(oprot)
22002 
      oprot.writeFieldEnd()
22003 
    oprot.writeFieldStop()
22004 
    oprot.writeStructEnd()
22005 
 
22006 
  def validate(self):
22007 
    return
22008 
 
22009 
 
22010 
  def __repr__(self):
22011 
    L = ['%s=%r' % (key, value)
22012 
      for key, value in self.__dict__.iteritems()]
22013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22014 
 
22015 
  def __eq__(self, other):
22016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22017 
 
22018 
  def __ne__(self, other):
22019 
    return not (self == other)
4386 anupam.sin 22020 
 
4662 rajveer 22021 
class markOrderAsLostInTransit_args:
22022 
  """
22023 
  Attributes:
22024 
   - orderId
22025 
  """
22026 
 
22027 
  thrift_spec = (
22028 
    None, # 0
22029 
    (1, TType.I64, 'orderId', None, None, ), # 1
22030 
  )
22031 
 
22032 
  def __init__(self, orderId=None,):
22033 
    self.orderId = orderId
22034 
 
22035 
  def read(self, iprot):
22036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22038 
      return
22039 
    iprot.readStructBegin()
22040 
    while True:
22041 
      (fname, ftype, fid) = iprot.readFieldBegin()
22042 
      if ftype == TType.STOP:
22043 
        break
22044 
      if fid == 1:
22045 
        if ftype == TType.I64:
22046 
          self.orderId = iprot.readI64();
22047 
        else:
22048 
          iprot.skip(ftype)
22049 
      else:
22050 
        iprot.skip(ftype)
22051 
      iprot.readFieldEnd()
22052 
    iprot.readStructEnd()
22053 
 
22054 
  def write(self, oprot):
22055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22057 
      return
22058 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22059 
    if self.orderId is not None:
22060 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22061 
      oprot.writeI64(self.orderId)
22062 
      oprot.writeFieldEnd()
22063 
    oprot.writeFieldStop()
22064 
    oprot.writeStructEnd()
22065 
 
22066 
  def validate(self):
22067 
    return
22068 
 
22069 
 
22070 
  def __repr__(self):
22071 
    L = ['%s=%r' % (key, value)
22072 
      for key, value in self.__dict__.iteritems()]
22073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22074 
 
22075 
  def __eq__(self, other):
22076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22077 
 
22078 
  def __ne__(self, other):
22079 
    return not (self == other)
22080 
 
22081 
class markOrderAsLostInTransit_result:
22082 
  """
22083 
  Attributes:
22084 
   - success
22085 
   - ex
22086 
  """
22087 
 
22088 
  thrift_spec = (
22089 
    (0, TType.BOOL, 'success', None, None, ), # 0
22090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22091 
  )
22092 
 
22093 
  def __init__(self, success=None, ex=None,):
22094 
    self.success = success
22095 
    self.ex = ex
22096 
 
22097 
  def read(self, iprot):
22098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22100 
      return
22101 
    iprot.readStructBegin()
22102 
    while True:
22103 
      (fname, ftype, fid) = iprot.readFieldBegin()
22104 
      if ftype == TType.STOP:
22105 
        break
22106 
      if fid == 0:
22107 
        if ftype == TType.BOOL:
22108 
          self.success = iprot.readBool();
22109 
        else:
22110 
          iprot.skip(ftype)
22111 
      elif fid == 1:
22112 
        if ftype == TType.STRUCT:
22113 
          self.ex = TransactionServiceException()
22114 
          self.ex.read(iprot)
22115 
        else:
22116 
          iprot.skip(ftype)
22117 
      else:
22118 
        iprot.skip(ftype)
22119 
      iprot.readFieldEnd()
22120 
    iprot.readStructEnd()
22121 
 
22122 
  def write(self, oprot):
22123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22125 
      return
22126 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22127 
    if self.success is not None:
22128 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22129 
      oprot.writeBool(self.success)
22130 
      oprot.writeFieldEnd()
22131 
    if self.ex is not None:
22132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22133 
      self.ex.write(oprot)
22134 
      oprot.writeFieldEnd()
22135 
    oprot.writeFieldStop()
22136 
    oprot.writeStructEnd()
22137 
 
22138 
  def validate(self):
22139 
    return
22140 
 
22141 
 
22142 
  def __repr__(self):
22143 
    L = ['%s=%r' % (key, value)
22144 
      for key, value in self.__dict__.iteritems()]
22145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22146 
 
22147 
  def __eq__(self, other):
22148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22149 
 
22150 
  def __ne__(self, other):
22151 
    return not (self == other)
22152 
 
4386 anupam.sin 22153 
class getOrderForAwb_args:
22154 
  """
22155 
  Attributes:
22156 
   - awb
22157 
  """
22158 
 
22159 
  thrift_spec = (
22160 
    None, # 0
22161 
    (1, TType.STRING, 'awb', None, None, ), # 1
22162 
  )
22163 
 
22164 
  def __init__(self, awb=None,):
22165 
    self.awb = awb
22166 
 
22167 
  def read(self, iprot):
22168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22170 
      return
22171 
    iprot.readStructBegin()
22172 
    while True:
22173 
      (fname, ftype, fid) = iprot.readFieldBegin()
22174 
      if ftype == TType.STOP:
22175 
        break
22176 
      if fid == 1:
22177 
        if ftype == TType.STRING:
22178 
          self.awb = iprot.readString();
22179 
        else:
22180 
          iprot.skip(ftype)
22181 
      else:
22182 
        iprot.skip(ftype)
22183 
      iprot.readFieldEnd()
22184 
    iprot.readStructEnd()
22185 
 
22186 
  def write(self, oprot):
22187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22189 
      return
22190 
    oprot.writeStructBegin('getOrderForAwb_args')
22191 
    if self.awb is not None:
22192 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22193 
      oprot.writeString(self.awb)
22194 
      oprot.writeFieldEnd()
22195 
    oprot.writeFieldStop()
22196 
    oprot.writeStructEnd()
22197 
 
22198 
  def validate(self):
22199 
    return
22200 
 
22201 
 
22202 
  def __repr__(self):
22203 
    L = ['%s=%r' % (key, value)
22204 
      for key, value in self.__dict__.iteritems()]
22205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22206 
 
22207 
  def __eq__(self, other):
22208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22209 
 
22210 
  def __ne__(self, other):
22211 
    return not (self == other)
22212 
 
22213 
class getOrderForAwb_result:
22214 
  """
22215 
  Attributes:
22216 
   - success
22217 
   - ex
22218 
  """
22219 
 
22220 
  thrift_spec = (
22221 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22223 
  )
22224 
 
22225 
  def __init__(self, success=None, ex=None,):
22226 
    self.success = success
22227 
    self.ex = ex
22228 
 
22229 
  def read(self, iprot):
22230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22232 
      return
22233 
    iprot.readStructBegin()
22234 
    while True:
22235 
      (fname, ftype, fid) = iprot.readFieldBegin()
22236 
      if ftype == TType.STOP:
22237 
        break
22238 
      if fid == 0:
22239 
        if ftype == TType.STRUCT:
22240 
          self.success = Order()
22241 
          self.success.read(iprot)
22242 
        else:
22243 
          iprot.skip(ftype)
22244 
      elif fid == 1:
22245 
        if ftype == TType.STRUCT:
22246 
          self.ex = TransactionServiceException()
22247 
          self.ex.read(iprot)
22248 
        else:
22249 
          iprot.skip(ftype)
22250 
      else:
22251 
        iprot.skip(ftype)
22252 
      iprot.readFieldEnd()
22253 
    iprot.readStructEnd()
22254 
 
22255 
  def write(self, oprot):
22256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22258 
      return
22259 
    oprot.writeStructBegin('getOrderForAwb_result')
22260 
    if self.success is not None:
22261 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22262 
      self.success.write(oprot)
22263 
      oprot.writeFieldEnd()
22264 
    if self.ex is not None:
22265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22266 
      self.ex.write(oprot)
22267 
      oprot.writeFieldEnd()
22268 
    oprot.writeFieldStop()
22269 
    oprot.writeStructEnd()
22270 
 
22271 
  def validate(self):
22272 
    return
22273 
 
22274 
 
22275 
  def __repr__(self):
22276 
    L = ['%s=%r' % (key, value)
22277 
      for key, value in self.__dict__.iteritems()]
22278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22279 
 
22280 
  def __eq__(self, other):
22281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22282 
 
22283 
  def __ne__(self, other):
22284 
    return not (self == other)
4506 phani.kuma 22285 
 
22286 
class getOrdersForProviderForStatus_args:
22287 
  """
22288 
  Attributes:
22289 
   - logistics_provider_id
4910 phani.kuma 22290 
   - order_status_list
4506 phani.kuma 22291 
  """
22292 
 
22293 
  thrift_spec = (
22294 
    None, # 0
22295 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22296 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22297 
  )
22298 
 
4910 phani.kuma 22299 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22300 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22301 
    self.order_status_list = order_status_list
4506 phani.kuma 22302 
 
22303 
  def read(self, iprot):
22304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22306 
      return
22307 
    iprot.readStructBegin()
22308 
    while True:
22309 
      (fname, ftype, fid) = iprot.readFieldBegin()
22310 
      if ftype == TType.STOP:
22311 
        break
22312 
      if fid == 1:
22313 
        if ftype == TType.I64:
22314 
          self.logistics_provider_id = iprot.readI64();
22315 
        else:
22316 
          iprot.skip(ftype)
22317 
      elif fid == 2:
4910 phani.kuma 22318 
        if ftype == TType.LIST:
22319 
          self.order_status_list = []
6188 rajveer 22320 
          (_etype513, _size510) = iprot.readListBegin()
22321 
          for _i514 in xrange(_size510):
22322 
            _elem515 = iprot.readI32();
22323 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22324 
          iprot.readListEnd()
4506 phani.kuma 22325 
        else:
22326 
          iprot.skip(ftype)
22327 
      else:
22328 
        iprot.skip(ftype)
22329 
      iprot.readFieldEnd()
22330 
    iprot.readStructEnd()
22331 
 
22332 
  def write(self, oprot):
22333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22335 
      return
22336 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22337 
    if self.logistics_provider_id is not None:
22338 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22339 
      oprot.writeI64(self.logistics_provider_id)
22340 
      oprot.writeFieldEnd()
4910 phani.kuma 22341 
    if self.order_status_list is not None:
22342 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22343 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22344 
      for iter516 in self.order_status_list:
22345 
        oprot.writeI32(iter516)
4910 phani.kuma 22346 
      oprot.writeListEnd()
4506 phani.kuma 22347 
      oprot.writeFieldEnd()
22348 
    oprot.writeFieldStop()
22349 
    oprot.writeStructEnd()
22350 
 
22351 
  def validate(self):
22352 
    return
22353 
 
22354 
 
22355 
  def __repr__(self):
22356 
    L = ['%s=%r' % (key, value)
22357 
      for key, value in self.__dict__.iteritems()]
22358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22359 
 
22360 
  def __eq__(self, other):
22361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22362 
 
22363 
  def __ne__(self, other):
22364 
    return not (self == other)
22365 
 
22366 
class getOrdersForProviderForStatus_result:
22367 
  """
22368 
  Attributes:
22369 
   - success
22370 
   - ex
22371 
  """
22372 
 
22373 
  thrift_spec = (
22374 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22376 
  )
22377 
 
22378 
  def __init__(self, success=None, ex=None,):
22379 
    self.success = success
22380 
    self.ex = ex
22381 
 
22382 
  def read(self, iprot):
22383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22385 
      return
22386 
    iprot.readStructBegin()
22387 
    while True:
22388 
      (fname, ftype, fid) = iprot.readFieldBegin()
22389 
      if ftype == TType.STOP:
22390 
        break
22391 
      if fid == 0:
22392 
        if ftype == TType.LIST:
22393 
          self.success = []
6188 rajveer 22394 
          (_etype520, _size517) = iprot.readListBegin()
22395 
          for _i521 in xrange(_size517):
22396 
            _elem522 = Order()
22397 
            _elem522.read(iprot)
22398 
            self.success.append(_elem522)
4506 phani.kuma 22399 
          iprot.readListEnd()
22400 
        else:
22401 
          iprot.skip(ftype)
22402 
      elif fid == 1:
22403 
        if ftype == TType.STRUCT:
22404 
          self.ex = TransactionServiceException()
22405 
          self.ex.read(iprot)
22406 
        else:
22407 
          iprot.skip(ftype)
22408 
      else:
22409 
        iprot.skip(ftype)
22410 
      iprot.readFieldEnd()
22411 
    iprot.readStructEnd()
22412 
 
22413 
  def write(self, oprot):
22414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22416 
      return
22417 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22418 
    if self.success is not None:
22419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22421 
      for iter523 in self.success:
22422 
        iter523.write(oprot)
4506 phani.kuma 22423 
      oprot.writeListEnd()
22424 
      oprot.writeFieldEnd()
22425 
    if self.ex is not None:
22426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22427 
      self.ex.write(oprot)
22428 
      oprot.writeFieldEnd()
22429 
    oprot.writeFieldStop()
22430 
    oprot.writeStructEnd()
22431 
 
22432 
  def validate(self):
22433 
    return
22434 
 
22435 
 
22436 
  def __repr__(self):
22437 
    L = ['%s=%r' % (key, value)
22438 
      for key, value in self.__dict__.iteritems()]
22439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22440 
 
22441 
  def __eq__(self, other):
22442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22443 
 
22444 
  def __ne__(self, other):
22445 
    return not (self == other)
4600 varun.gupt 22446 
 
22447 
class getBilledOrdersForVendor_args:
22448 
  """
22449 
  Attributes:
22450 
   - vendorId
22451 
   - billingDateFrom
22452 
   - billingDateTo
22453 
  """
22454 
 
22455 
  thrift_spec = (
22456 
    None, # 0
22457 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22458 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22459 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22460 
  )
22461 
 
22462 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22463 
    self.vendorId = vendorId
22464 
    self.billingDateFrom = billingDateFrom
22465 
    self.billingDateTo = billingDateTo
22466 
 
22467 
  def read(self, iprot):
22468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22470 
      return
22471 
    iprot.readStructBegin()
22472 
    while True:
22473 
      (fname, ftype, fid) = iprot.readFieldBegin()
22474 
      if ftype == TType.STOP:
22475 
        break
22476 
      if fid == 1:
22477 
        if ftype == TType.I64:
22478 
          self.vendorId = iprot.readI64();
22479 
        else:
22480 
          iprot.skip(ftype)
22481 
      elif fid == 2:
22482 
        if ftype == TType.I64:
22483 
          self.billingDateFrom = iprot.readI64();
22484 
        else:
22485 
          iprot.skip(ftype)
22486 
      elif fid == 3:
22487 
        if ftype == TType.I64:
22488 
          self.billingDateTo = iprot.readI64();
22489 
        else:
22490 
          iprot.skip(ftype)
22491 
      else:
22492 
        iprot.skip(ftype)
22493 
      iprot.readFieldEnd()
22494 
    iprot.readStructEnd()
22495 
 
22496 
  def write(self, oprot):
22497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22499 
      return
22500 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22501 
    if self.vendorId is not None:
22502 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22503 
      oprot.writeI64(self.vendorId)
22504 
      oprot.writeFieldEnd()
22505 
    if self.billingDateFrom is not None:
22506 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22507 
      oprot.writeI64(self.billingDateFrom)
22508 
      oprot.writeFieldEnd()
22509 
    if self.billingDateTo is not None:
22510 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22511 
      oprot.writeI64(self.billingDateTo)
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 getBilledOrdersForVendor_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 
          (_etype527, _size524) = iprot.readListBegin()
22560 
          for _i528 in xrange(_size524):
22561 
            _elem529 = Order()
22562 
            _elem529.read(iprot)
22563 
            self.success.append(_elem529)
4600 varun.gupt 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('getBilledOrdersForVendor_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 iter530 in self.success:
22587 
        iter530.write(oprot)
4600 varun.gupt 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)
22611 
 
4607 rajveer 22612 
class getSlippedSippingDateOrders_args:
22613 
 
22614 
  thrift_spec = (
22615 
  )
22616 
 
22617 
  def read(self, iprot):
22618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22620 
      return
22621 
    iprot.readStructBegin()
22622 
    while True:
22623 
      (fname, ftype, fid) = iprot.readFieldBegin()
22624 
      if ftype == TType.STOP:
22625 
        break
22626 
      else:
22627 
        iprot.skip(ftype)
22628 
      iprot.readFieldEnd()
22629 
    iprot.readStructEnd()
22630 
 
22631 
  def write(self, oprot):
22632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22634 
      return
22635 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22636 
    oprot.writeFieldStop()
22637 
    oprot.writeStructEnd()
22638 
 
22639 
  def validate(self):
22640 
    return
22641 
 
22642 
 
22643 
  def __repr__(self):
22644 
    L = ['%s=%r' % (key, value)
22645 
      for key, value in self.__dict__.iteritems()]
22646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22647 
 
22648 
  def __eq__(self, other):
22649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22650 
 
22651 
  def __ne__(self, other):
22652 
    return not (self == other)
22653 
 
22654 
class getSlippedSippingDateOrders_result:
22655 
  """
22656 
  Attributes:
22657 
   - success
22658 
   - ex
22659 
  """
22660 
 
22661 
  thrift_spec = (
22662 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22663 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22664 
  )
22665 
 
22666 
  def __init__(self, success=None, ex=None,):
22667 
    self.success = success
22668 
    self.ex = ex
22669 
 
22670 
  def read(self, iprot):
22671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22673 
      return
22674 
    iprot.readStructBegin()
22675 
    while True:
22676 
      (fname, ftype, fid) = iprot.readFieldBegin()
22677 
      if ftype == TType.STOP:
22678 
        break
22679 
      if fid == 0:
22680 
        if ftype == TType.LIST:
22681 
          self.success = []
6188 rajveer 22682 
          (_etype534, _size531) = iprot.readListBegin()
22683 
          for _i535 in xrange(_size531):
22684 
            _elem536 = Order()
22685 
            _elem536.read(iprot)
22686 
            self.success.append(_elem536)
4607 rajveer 22687 
          iprot.readListEnd()
22688 
        else:
22689 
          iprot.skip(ftype)
22690 
      elif fid == 1:
22691 
        if ftype == TType.STRUCT:
22692 
          self.ex = TransactionServiceException()
22693 
          self.ex.read(iprot)
22694 
        else:
22695 
          iprot.skip(ftype)
22696 
      else:
22697 
        iprot.skip(ftype)
22698 
      iprot.readFieldEnd()
22699 
    iprot.readStructEnd()
22700 
 
22701 
  def write(self, oprot):
22702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22704 
      return
22705 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22706 
    if self.success is not None:
22707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22709 
      for iter537 in self.success:
22710 
        iter537.write(oprot)
4607 rajveer 22711 
      oprot.writeListEnd()
22712 
      oprot.writeFieldEnd()
22713 
    if self.ex is not None:
22714 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22715 
      self.ex.write(oprot)
22716 
      oprot.writeFieldEnd()
22717 
    oprot.writeFieldStop()
22718 
    oprot.writeStructEnd()
22719 
 
22720 
  def validate(self):
22721 
    return
22722 
 
22723 
 
22724 
  def __repr__(self):
22725 
    L = ['%s=%r' % (key, value)
22726 
      for key, value in self.__dict__.iteritems()]
22727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22728 
 
22729 
  def __eq__(self, other):
22730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22731 
 
22732 
  def __ne__(self, other):
22733 
    return not (self == other)
22734 
 
4709 rajveer 22735 
class getCancelledOrders_args:
22736 
  """
22737 
  Attributes:
22738 
   - cancelDateFrom
22739 
   - cancelDateTo
22740 
  """
22741 
 
22742 
  thrift_spec = (
22743 
    None, # 0
22744 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22745 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22746 
  )
22747 
 
22748 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22749 
    self.cancelDateFrom = cancelDateFrom
22750 
    self.cancelDateTo = cancelDateTo
22751 
 
22752 
  def read(self, iprot):
22753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22755 
      return
22756 
    iprot.readStructBegin()
22757 
    while True:
22758 
      (fname, ftype, fid) = iprot.readFieldBegin()
22759 
      if ftype == TType.STOP:
22760 
        break
22761 
      if fid == 1:
22762 
        if ftype == TType.I64:
22763 
          self.cancelDateFrom = iprot.readI64();
22764 
        else:
22765 
          iprot.skip(ftype)
22766 
      elif fid == 2:
22767 
        if ftype == TType.I64:
22768 
          self.cancelDateTo = iprot.readI64();
22769 
        else:
22770 
          iprot.skip(ftype)
22771 
      else:
22772 
        iprot.skip(ftype)
22773 
      iprot.readFieldEnd()
22774 
    iprot.readStructEnd()
22775 
 
22776 
  def write(self, oprot):
22777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22779 
      return
22780 
    oprot.writeStructBegin('getCancelledOrders_args')
22781 
    if self.cancelDateFrom is not None:
22782 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22783 
      oprot.writeI64(self.cancelDateFrom)
22784 
      oprot.writeFieldEnd()
22785 
    if self.cancelDateTo is not None:
22786 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22787 
      oprot.writeI64(self.cancelDateTo)
22788 
      oprot.writeFieldEnd()
22789 
    oprot.writeFieldStop()
22790 
    oprot.writeStructEnd()
22791 
 
22792 
  def validate(self):
22793 
    return
22794 
 
22795 
 
22796 
  def __repr__(self):
22797 
    L = ['%s=%r' % (key, value)
22798 
      for key, value in self.__dict__.iteritems()]
22799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22800 
 
22801 
  def __eq__(self, other):
22802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22803 
 
22804 
  def __ne__(self, other):
22805 
    return not (self == other)
22806 
 
22807 
class getCancelledOrders_result:
22808 
  """
22809 
  Attributes:
22810 
   - success
22811 
   - ex
22812 
  """
22813 
 
22814 
  thrift_spec = (
22815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22817 
  )
22818 
 
22819 
  def __init__(self, success=None, ex=None,):
22820 
    self.success = success
22821 
    self.ex = ex
22822 
 
22823 
  def read(self, iprot):
22824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22826 
      return
22827 
    iprot.readStructBegin()
22828 
    while True:
22829 
      (fname, ftype, fid) = iprot.readFieldBegin()
22830 
      if ftype == TType.STOP:
22831 
        break
22832 
      if fid == 0:
22833 
        if ftype == TType.LIST:
22834 
          self.success = []
6188 rajveer 22835 
          (_etype541, _size538) = iprot.readListBegin()
22836 
          for _i542 in xrange(_size538):
22837 
            _elem543 = Order()
22838 
            _elem543.read(iprot)
22839 
            self.success.append(_elem543)
4709 rajveer 22840 
          iprot.readListEnd()
22841 
        else:
22842 
          iprot.skip(ftype)
22843 
      elif fid == 1:
22844 
        if ftype == TType.STRUCT:
22845 
          self.ex = TransactionServiceException()
22846 
          self.ex.read(iprot)
22847 
        else:
22848 
          iprot.skip(ftype)
22849 
      else:
22850 
        iprot.skip(ftype)
22851 
      iprot.readFieldEnd()
22852 
    iprot.readStructEnd()
22853 
 
22854 
  def write(self, oprot):
22855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22857 
      return
22858 
    oprot.writeStructBegin('getCancelledOrders_result')
22859 
    if self.success is not None:
22860 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22861 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22862 
      for iter544 in self.success:
22863 
        iter544.write(oprot)
4709 rajveer 22864 
      oprot.writeListEnd()
22865 
      oprot.writeFieldEnd()
22866 
    if self.ex is not None:
22867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22868 
      self.ex.write(oprot)
22869 
      oprot.writeFieldEnd()
22870 
    oprot.writeFieldStop()
22871 
    oprot.writeStructEnd()
22872 
 
22873 
  def validate(self):
22874 
    return
22875 
 
22876 
 
22877 
  def __repr__(self):
22878 
    L = ['%s=%r' % (key, value)
22879 
      for key, value in self.__dict__.iteritems()]
22880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22881 
 
22882 
  def __eq__(self, other):
22883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22884 
 
22885 
  def __ne__(self, other):
22886 
    return not (self == other)
22887 
 
4600 varun.gupt 22888 
class saveBluedartSettlements_args:
22889 
  """
22890 
  Attributes:
22891 
   - mapAWBAndAmount
22892 
  """
22893 
 
22894 
  thrift_spec = (
22895 
    None, # 0
22896 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22897 
  )
22898 
 
22899 
  def __init__(self, mapAWBAndAmount=None,):
22900 
    self.mapAWBAndAmount = mapAWBAndAmount
22901 
 
22902 
  def read(self, iprot):
22903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22905 
      return
22906 
    iprot.readStructBegin()
22907 
    while True:
22908 
      (fname, ftype, fid) = iprot.readFieldBegin()
22909 
      if ftype == TType.STOP:
22910 
        break
22911 
      if fid == 1:
22912 
        if ftype == TType.MAP:
22913 
          self.mapAWBAndAmount = {}
6188 rajveer 22914 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22915 
          for _i549 in xrange(_size545):
22916 
            _key550 = iprot.readI64();
22917 
            _val551 = iprot.readDouble();
22918 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22919 
          iprot.readMapEnd()
22920 
        else:
22921 
          iprot.skip(ftype)
22922 
      else:
22923 
        iprot.skip(ftype)
22924 
      iprot.readFieldEnd()
22925 
    iprot.readStructEnd()
22926 
 
22927 
  def write(self, oprot):
22928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22930 
      return
22931 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22932 
    if self.mapAWBAndAmount is not None:
22933 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22934 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22935 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22936 
        oprot.writeI64(kiter552)
22937 
        oprot.writeDouble(viter553)
4600 varun.gupt 22938 
      oprot.writeMapEnd()
22939 
      oprot.writeFieldEnd()
22940 
    oprot.writeFieldStop()
22941 
    oprot.writeStructEnd()
22942 
 
22943 
  def validate(self):
22944 
    return
22945 
 
22946 
 
22947 
  def __repr__(self):
22948 
    L = ['%s=%r' % (key, value)
22949 
      for key, value in self.__dict__.iteritems()]
22950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22951 
 
22952 
  def __eq__(self, other):
22953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22954 
 
22955 
  def __ne__(self, other):
22956 
    return not (self == other)
22957 
 
22958 
class saveBluedartSettlements_result:
22959 
  """
22960 
  Attributes:
22961 
   - ex
22962 
  """
22963 
 
22964 
  thrift_spec = (
22965 
    None, # 0
22966 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22967 
  )
22968 
 
22969 
  def __init__(self, ex=None,):
22970 
    self.ex = ex
22971 
 
22972 
  def read(self, iprot):
22973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22975 
      return
22976 
    iprot.readStructBegin()
22977 
    while True:
22978 
      (fname, ftype, fid) = iprot.readFieldBegin()
22979 
      if ftype == TType.STOP:
22980 
        break
22981 
      if fid == 1:
22982 
        if ftype == TType.STRUCT:
22983 
          self.ex = TransactionServiceException()
22984 
          self.ex.read(iprot)
22985 
        else:
22986 
          iprot.skip(ftype)
22987 
      else:
22988 
        iprot.skip(ftype)
22989 
      iprot.readFieldEnd()
22990 
    iprot.readStructEnd()
22991 
 
22992 
  def write(self, oprot):
22993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22995 
      return
22996 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22997 
    if self.ex is not None:
22998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22999 
      self.ex.write(oprot)
23000 
      oprot.writeFieldEnd()
23001 
    oprot.writeFieldStop()
23002 
    oprot.writeStructEnd()
23003 
 
23004 
  def validate(self):
23005 
    return
23006 
 
23007 
 
23008 
  def __repr__(self):
23009 
    L = ['%s=%r' % (key, value)
23010 
      for key, value in self.__dict__.iteritems()]
23011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23012 
 
23013 
  def __eq__(self, other):
23014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23015 
 
23016 
  def __ne__(self, other):
23017 
    return not (self == other)
23018 
 
23019 
class savePaymentSettlements_args:
23020 
  """
23021 
  Attributes:
23022 
   - settlementDate
23023 
   - paymentGatewayId
4905 varun.gupt 23024 
   - referenceId
4600 varun.gupt 23025 
   - serviceTax
23026 
   - otherCharges
23027 
   - netCollection
23028 
  """
23029 
 
23030 
  thrift_spec = (
23031 
    None, # 0
23032 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23033 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23034 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23035 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23036 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23037 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23038 
  )
23039 
 
4905 varun.gupt 23040 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23041 
    self.settlementDate = settlementDate
23042 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23043 
    self.referenceId = referenceId
4600 varun.gupt 23044 
    self.serviceTax = serviceTax
23045 
    self.otherCharges = otherCharges
23046 
    self.netCollection = netCollection
23047 
 
23048 
  def read(self, iprot):
23049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23051 
      return
23052 
    iprot.readStructBegin()
23053 
    while True:
23054 
      (fname, ftype, fid) = iprot.readFieldBegin()
23055 
      if ftype == TType.STOP:
23056 
        break
23057 
      if fid == 1:
23058 
        if ftype == TType.I64:
23059 
          self.settlementDate = iprot.readI64();
23060 
        else:
23061 
          iprot.skip(ftype)
23062 
      elif fid == 2:
23063 
        if ftype == TType.I64:
23064 
          self.paymentGatewayId = iprot.readI64();
23065 
        else:
23066 
          iprot.skip(ftype)
23067 
      elif fid == 3:
23068 
        if ftype == TType.I64:
4905 varun.gupt 23069 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23070 
        else:
23071 
          iprot.skip(ftype)
23072 
      elif fid == 4:
23073 
        if ftype == TType.DOUBLE:
23074 
          self.serviceTax = iprot.readDouble();
23075 
        else:
23076 
          iprot.skip(ftype)
23077 
      elif fid == 5:
23078 
        if ftype == TType.DOUBLE:
23079 
          self.otherCharges = iprot.readDouble();
23080 
        else:
23081 
          iprot.skip(ftype)
23082 
      elif fid == 6:
23083 
        if ftype == TType.DOUBLE:
23084 
          self.netCollection = iprot.readDouble();
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('savePaymentSettlements_args')
23097 
    if self.settlementDate is not None:
23098 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23099 
      oprot.writeI64(self.settlementDate)
23100 
      oprot.writeFieldEnd()
23101 
    if self.paymentGatewayId is not None:
23102 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23103 
      oprot.writeI64(self.paymentGatewayId)
23104 
      oprot.writeFieldEnd()
4905 varun.gupt 23105 
    if self.referenceId is not None:
23106 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23107 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23108 
      oprot.writeFieldEnd()
23109 
    if self.serviceTax is not None:
23110 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23111 
      oprot.writeDouble(self.serviceTax)
23112 
      oprot.writeFieldEnd()
23113 
    if self.otherCharges is not None:
23114 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23115 
      oprot.writeDouble(self.otherCharges)
23116 
      oprot.writeFieldEnd()
23117 
    if self.netCollection is not None:
23118 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23119 
      oprot.writeDouble(self.netCollection)
23120 
      oprot.writeFieldEnd()
23121 
    oprot.writeFieldStop()
23122 
    oprot.writeStructEnd()
23123 
 
23124 
  def validate(self):
23125 
    return
23126 
 
23127 
 
23128 
  def __repr__(self):
23129 
    L = ['%s=%r' % (key, value)
23130 
      for key, value in self.__dict__.iteritems()]
23131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23132 
 
23133 
  def __eq__(self, other):
23134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23135 
 
23136 
  def __ne__(self, other):
23137 
    return not (self == other)
23138 
 
23139 
class savePaymentSettlements_result:
23140 
  """
23141 
  Attributes:
23142 
   - ex
23143 
  """
23144 
 
23145 
  thrift_spec = (
23146 
    None, # 0
23147 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23148 
  )
23149 
 
23150 
  def __init__(self, ex=None,):
23151 
    self.ex = ex
23152 
 
23153 
  def read(self, iprot):
23154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23156 
      return
23157 
    iprot.readStructBegin()
23158 
    while True:
23159 
      (fname, ftype, fid) = iprot.readFieldBegin()
23160 
      if ftype == TType.STOP:
23161 
        break
23162 
      if fid == 1:
23163 
        if ftype == TType.STRUCT:
23164 
          self.ex = TransactionServiceException()
23165 
          self.ex.read(iprot)
23166 
        else:
23167 
          iprot.skip(ftype)
23168 
      else:
23169 
        iprot.skip(ftype)
23170 
      iprot.readFieldEnd()
23171 
    iprot.readStructEnd()
23172 
 
23173 
  def write(self, oprot):
23174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23176 
      return
23177 
    oprot.writeStructBegin('savePaymentSettlements_result')
23178 
    if self.ex is not None:
23179 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23180 
      self.ex.write(oprot)
23181 
      oprot.writeFieldEnd()
23182 
    oprot.writeFieldStop()
23183 
    oprot.writeStructEnd()
23184 
 
23185 
  def validate(self):
23186 
    return
23187 
 
23188 
 
23189 
  def __repr__(self):
23190 
    L = ['%s=%r' % (key, value)
23191 
      for key, value in self.__dict__.iteritems()]
23192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23193 
 
23194 
  def __eq__(self, other):
23195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23196 
 
23197 
  def __ne__(self, other):
23198 
    return not (self == other)
23199 
 
23200 
class saveEBSSettlementSummary_args:
23201 
  """
23202 
  Attributes:
23203 
   - settlementId
23204 
   - settlementDate
23205 
   - transactionDateFrom
23206 
   - transactionDateTo
23207 
   - amount
23208 
  """
23209 
 
23210 
  thrift_spec = (
23211 
    None, # 0
23212 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23213 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23214 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23215 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23216 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23217 
  )
23218 
 
23219 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23220 
    self.settlementId = settlementId
23221 
    self.settlementDate = settlementDate
23222 
    self.transactionDateFrom = transactionDateFrom
23223 
    self.transactionDateTo = transactionDateTo
23224 
    self.amount = amount
23225 
 
23226 
  def read(self, iprot):
23227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23229 
      return
23230 
    iprot.readStructBegin()
23231 
    while True:
23232 
      (fname, ftype, fid) = iprot.readFieldBegin()
23233 
      if ftype == TType.STOP:
23234 
        break
23235 
      if fid == 1:
23236 
        if ftype == TType.I64:
23237 
          self.settlementId = iprot.readI64();
23238 
        else:
23239 
          iprot.skip(ftype)
23240 
      elif fid == 2:
23241 
        if ftype == TType.I64:
23242 
          self.settlementDate = iprot.readI64();
23243 
        else:
23244 
          iprot.skip(ftype)
23245 
      elif fid == 3:
23246 
        if ftype == TType.I64:
23247 
          self.transactionDateFrom = iprot.readI64();
23248 
        else:
23249 
          iprot.skip(ftype)
23250 
      elif fid == 4:
23251 
        if ftype == TType.I64:
23252 
          self.transactionDateTo = iprot.readI64();
23253 
        else:
23254 
          iprot.skip(ftype)
23255 
      elif fid == 5:
23256 
        if ftype == TType.DOUBLE:
23257 
          self.amount = iprot.readDouble();
23258 
        else:
23259 
          iprot.skip(ftype)
23260 
      else:
23261 
        iprot.skip(ftype)
23262 
      iprot.readFieldEnd()
23263 
    iprot.readStructEnd()
23264 
 
23265 
  def write(self, oprot):
23266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23268 
      return
23269 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23270 
    if self.settlementId is not None:
23271 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23272 
      oprot.writeI64(self.settlementId)
23273 
      oprot.writeFieldEnd()
23274 
    if self.settlementDate is not None:
23275 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23276 
      oprot.writeI64(self.settlementDate)
23277 
      oprot.writeFieldEnd()
23278 
    if self.transactionDateFrom is not None:
23279 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23280 
      oprot.writeI64(self.transactionDateFrom)
23281 
      oprot.writeFieldEnd()
23282 
    if self.transactionDateTo is not None:
23283 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23284 
      oprot.writeI64(self.transactionDateTo)
23285 
      oprot.writeFieldEnd()
23286 
    if self.amount is not None:
23287 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23288 
      oprot.writeDouble(self.amount)
23289 
      oprot.writeFieldEnd()
23290 
    oprot.writeFieldStop()
23291 
    oprot.writeStructEnd()
23292 
 
23293 
  def validate(self):
23294 
    return
23295 
 
23296 
 
23297 
  def __repr__(self):
23298 
    L = ['%s=%r' % (key, value)
23299 
      for key, value in self.__dict__.iteritems()]
23300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23301 
 
23302 
  def __eq__(self, other):
23303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23304 
 
23305 
  def __ne__(self, other):
23306 
    return not (self == other)
23307 
 
23308 
class saveEBSSettlementSummary_result:
23309 
  """
23310 
  Attributes:
23311 
   - ex
23312 
  """
23313 
 
23314 
  thrift_spec = (
23315 
    None, # 0
23316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23317 
  )
23318 
 
23319 
  def __init__(self, ex=None,):
23320 
    self.ex = ex
23321 
 
23322 
  def read(self, iprot):
23323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23325 
      return
23326 
    iprot.readStructBegin()
23327 
    while True:
23328 
      (fname, ftype, fid) = iprot.readFieldBegin()
23329 
      if ftype == TType.STOP:
23330 
        break
23331 
      if fid == 1:
23332 
        if ftype == TType.STRUCT:
23333 
          self.ex = TransactionServiceException()
23334 
          self.ex.read(iprot)
23335 
        else:
23336 
          iprot.skip(ftype)
23337 
      else:
23338 
        iprot.skip(ftype)
23339 
      iprot.readFieldEnd()
23340 
    iprot.readStructEnd()
23341 
 
23342 
  def write(self, oprot):
23343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23345 
      return
23346 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23347 
    if self.ex is not None:
23348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23349 
      self.ex.write(oprot)
23350 
      oprot.writeFieldEnd()
23351 
    oprot.writeFieldStop()
23352 
    oprot.writeStructEnd()
23353 
 
23354 
  def validate(self):
23355 
    return
23356 
 
23357 
 
23358 
  def __repr__(self):
23359 
    L = ['%s=%r' % (key, value)
23360 
      for key, value in self.__dict__.iteritems()]
23361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23362 
 
23363 
  def __eq__(self, other):
23364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23365 
 
23366 
  def __ne__(self, other):
23367 
    return not (self == other)
23368 
 
5386 phani.kuma 23369 
class getSettlementForPrepaid_args:
4600 varun.gupt 23370 
  """
23371 
  Attributes:
5189 varun.gupt 23372 
   - referenceId
23373 
   - isRefund
4600 varun.gupt 23374 
  """
23375 
 
23376 
  thrift_spec = (
23377 
    None, # 0
5189 varun.gupt 23378 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23379 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23380 
  )
23381 
 
5386 phani.kuma 23382 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23383 
    self.referenceId = referenceId
23384 
    self.isRefund = isRefund
4600 varun.gupt 23385 
 
23386 
  def read(self, iprot):
23387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23389 
      return
23390 
    iprot.readStructBegin()
23391 
    while True:
23392 
      (fname, ftype, fid) = iprot.readFieldBegin()
23393 
      if ftype == TType.STOP:
23394 
        break
23395 
      if fid == 1:
23396 
        if ftype == TType.I64:
5189 varun.gupt 23397 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23398 
        else:
23399 
          iprot.skip(ftype)
5189 varun.gupt 23400 
      elif fid == 2:
23401 
        if ftype == TType.BOOL:
23402 
          self.isRefund = iprot.readBool();
23403 
        else:
23404 
          iprot.skip(ftype)
4600 varun.gupt 23405 
      else:
23406 
        iprot.skip(ftype)
23407 
      iprot.readFieldEnd()
23408 
    iprot.readStructEnd()
23409 
 
23410 
  def write(self, oprot):
23411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23413 
      return
5386 phani.kuma 23414 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23415 
    if self.referenceId is not None:
23416 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23417 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23418 
      oprot.writeFieldEnd()
5386 phani.kuma 23419 
    if self.isRefund is not None:
23420 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23421 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23422 
      oprot.writeFieldEnd()
5386 phani.kuma 23423 
    oprot.writeFieldStop()
23424 
    oprot.writeStructEnd()
23425 
 
23426 
  def validate(self):
23427 
    return
23428 
 
23429 
 
23430 
  def __repr__(self):
23431 
    L = ['%s=%r' % (key, value)
23432 
      for key, value in self.__dict__.iteritems()]
23433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23434 
 
23435 
  def __eq__(self, other):
23436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23437 
 
23438 
  def __ne__(self, other):
23439 
    return not (self == other)
23440 
 
23441 
class getSettlementForPrepaid_result:
23442 
  """
23443 
  Attributes:
23444 
   - success
23445 
   - ex
23446 
  """
23447 
 
23448 
  thrift_spec = (
23449 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23450 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23451 
  )
23452 
 
23453 
  def __init__(self, success=None, ex=None,):
23454 
    self.success = success
23455 
    self.ex = ex
23456 
 
23457 
  def read(self, iprot):
23458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23460 
      return
23461 
    iprot.readStructBegin()
23462 
    while True:
23463 
      (fname, ftype, fid) = iprot.readFieldBegin()
23464 
      if ftype == TType.STOP:
23465 
        break
23466 
      if fid == 0:
23467 
        if ftype == TType.STRUCT:
23468 
          self.success = PaymentSettlement()
23469 
          self.success.read(iprot)
23470 
        else:
23471 
          iprot.skip(ftype)
23472 
      elif fid == 1:
23473 
        if ftype == TType.STRUCT:
23474 
          self.ex = TransactionServiceException()
23475 
          self.ex.read(iprot)
23476 
        else:
23477 
          iprot.skip(ftype)
23478 
      else:
23479 
        iprot.skip(ftype)
23480 
      iprot.readFieldEnd()
23481 
    iprot.readStructEnd()
23482 
 
23483 
  def write(self, oprot):
23484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23486 
      return
23487 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23488 
    if self.success is not None:
23489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23490 
      self.success.write(oprot)
23491 
      oprot.writeFieldEnd()
23492 
    if self.ex is not None:
23493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23494 
      self.ex.write(oprot)
23495 
      oprot.writeFieldEnd()
23496 
    oprot.writeFieldStop()
23497 
    oprot.writeStructEnd()
23498 
 
23499 
  def validate(self):
23500 
    return
23501 
 
23502 
 
23503 
  def __repr__(self):
23504 
    L = ['%s=%r' % (key, value)
23505 
      for key, value in self.__dict__.iteritems()]
23506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23507 
 
23508 
  def __eq__(self, other):
23509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23510 
 
23511 
  def __ne__(self, other):
23512 
    return not (self == other)
23513 
 
23514 
class getSettlementForCod_args:
23515 
  """
23516 
  Attributes:
23517 
   - orderId
23518 
   - isRefund
23519 
  """
23520 
 
23521 
  thrift_spec = (
23522 
    None, # 0
23523 
    (1, TType.I64, 'orderId', None, None, ), # 1
23524 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23525 
  )
23526 
 
23527 
  def __init__(self, orderId=None, isRefund=None,):
23528 
    self.orderId = orderId
23529 
    self.isRefund = isRefund
23530 
 
23531 
  def read(self, iprot):
23532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23534 
      return
23535 
    iprot.readStructBegin()
23536 
    while True:
23537 
      (fname, ftype, fid) = iprot.readFieldBegin()
23538 
      if ftype == TType.STOP:
23539 
        break
23540 
      if fid == 1:
23541 
        if ftype == TType.I64:
23542 
          self.orderId = iprot.readI64();
23543 
        else:
23544 
          iprot.skip(ftype)
23545 
      elif fid == 2:
23546 
        if ftype == TType.BOOL:
23547 
          self.isRefund = iprot.readBool();
23548 
        else:
23549 
          iprot.skip(ftype)
23550 
      else:
23551 
        iprot.skip(ftype)
23552 
      iprot.readFieldEnd()
23553 
    iprot.readStructEnd()
23554 
 
23555 
  def write(self, oprot):
23556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23558 
      return
23559 
    oprot.writeStructBegin('getSettlementForCod_args')
23560 
    if self.orderId is not None:
23561 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23562 
      oprot.writeI64(self.orderId)
23563 
      oprot.writeFieldEnd()
5189 varun.gupt 23564 
    if self.isRefund is not None:
5386 phani.kuma 23565 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23566 
      oprot.writeBool(self.isRefund)
23567 
      oprot.writeFieldEnd()
4600 varun.gupt 23568 
    oprot.writeFieldStop()
23569 
    oprot.writeStructEnd()
23570 
 
23571 
  def validate(self):
23572 
    return
23573 
 
23574 
 
23575 
  def __repr__(self):
23576 
    L = ['%s=%r' % (key, value)
23577 
      for key, value in self.__dict__.iteritems()]
23578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23579 
 
23580 
  def __eq__(self, other):
23581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23582 
 
23583 
  def __ne__(self, other):
23584 
    return not (self == other)
23585 
 
5386 phani.kuma 23586 
class getSettlementForCod_result:
4600 varun.gupt 23587 
  """
23588 
  Attributes:
23589 
   - success
23590 
   - ex
23591 
  """
23592 
 
23593 
  thrift_spec = (
23594 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23595 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23596 
  )
23597 
 
23598 
  def __init__(self, success=None, ex=None,):
23599 
    self.success = success
23600 
    self.ex = ex
23601 
 
23602 
  def read(self, iprot):
23603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23605 
      return
23606 
    iprot.readStructBegin()
23607 
    while True:
23608 
      (fname, ftype, fid) = iprot.readFieldBegin()
23609 
      if ftype == TType.STOP:
23610 
        break
23611 
      if fid == 0:
23612 
        if ftype == TType.STRUCT:
23613 
          self.success = PaymentSettlement()
23614 
          self.success.read(iprot)
23615 
        else:
23616 
          iprot.skip(ftype)
23617 
      elif fid == 1:
23618 
        if ftype == TType.STRUCT:
23619 
          self.ex = TransactionServiceException()
23620 
          self.ex.read(iprot)
23621 
        else:
23622 
          iprot.skip(ftype)
23623 
      else:
23624 
        iprot.skip(ftype)
23625 
      iprot.readFieldEnd()
23626 
    iprot.readStructEnd()
23627 
 
23628 
  def write(self, oprot):
23629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23631 
      return
5386 phani.kuma 23632 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23633 
    if self.success is not None:
23634 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23635 
      self.success.write(oprot)
23636 
      oprot.writeFieldEnd()
23637 
    if self.ex is not None:
23638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23639 
      self.ex.write(oprot)
23640 
      oprot.writeFieldEnd()
23641 
    oprot.writeFieldStop()
23642 
    oprot.writeStructEnd()
23643 
 
23644 
  def validate(self):
23645 
    return
23646 
 
23647 
 
23648 
  def __repr__(self):
23649 
    L = ['%s=%r' % (key, value)
23650 
      for key, value in self.__dict__.iteritems()]
23651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23652 
 
23653 
  def __eq__(self, other):
23654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23655 
 
23656 
  def __ne__(self, other):
23657 
    return not (self == other)
23658 
 
23659 
class getEBSSettlementSummaries_args:
23660 
 
23661 
  thrift_spec = (
23662 
  )
23663 
 
23664 
  def read(self, iprot):
23665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23667 
      return
23668 
    iprot.readStructBegin()
23669 
    while True:
23670 
      (fname, ftype, fid) = iprot.readFieldBegin()
23671 
      if ftype == TType.STOP:
23672 
        break
23673 
      else:
23674 
        iprot.skip(ftype)
23675 
      iprot.readFieldEnd()
23676 
    iprot.readStructEnd()
23677 
 
23678 
  def write(self, oprot):
23679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23681 
      return
23682 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23683 
    oprot.writeFieldStop()
23684 
    oprot.writeStructEnd()
23685 
 
23686 
  def validate(self):
23687 
    return
23688 
 
23689 
 
23690 
  def __repr__(self):
23691 
    L = ['%s=%r' % (key, value)
23692 
      for key, value in self.__dict__.iteritems()]
23693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23694 
 
23695 
  def __eq__(self, other):
23696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23697 
 
23698 
  def __ne__(self, other):
23699 
    return not (self == other)
23700 
 
23701 
class getEBSSettlementSummaries_result:
23702 
  """
23703 
  Attributes:
23704 
   - success
23705 
   - ex
23706 
  """
23707 
 
23708 
  thrift_spec = (
23709 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23710 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23711 
  )
23712 
 
23713 
  def __init__(self, success=None, ex=None,):
23714 
    self.success = success
23715 
    self.ex = ex
23716 
 
23717 
  def read(self, iprot):
23718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23720 
      return
23721 
    iprot.readStructBegin()
23722 
    while True:
23723 
      (fname, ftype, fid) = iprot.readFieldBegin()
23724 
      if ftype == TType.STOP:
23725 
        break
23726 
      if fid == 0:
23727 
        if ftype == TType.MAP:
23728 
          self.success = {}
6188 rajveer 23729 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23730 
          for _i558 in xrange(_size554):
23731 
            _key559 = iprot.readI64();
23732 
            _val560 = iprot.readString();
23733 
            self.success[_key559] = _val560
4600 varun.gupt 23734 
          iprot.readMapEnd()
23735 
        else:
23736 
          iprot.skip(ftype)
23737 
      elif fid == 1:
23738 
        if ftype == TType.STRUCT:
23739 
          self.ex = TransactionServiceException()
23740 
          self.ex.read(iprot)
23741 
        else:
23742 
          iprot.skip(ftype)
23743 
      else:
23744 
        iprot.skip(ftype)
23745 
      iprot.readFieldEnd()
23746 
    iprot.readStructEnd()
23747 
 
23748 
  def write(self, oprot):
23749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23751 
      return
23752 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23753 
    if self.success is not None:
23754 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23755 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23756 
      for kiter561,viter562 in self.success.items():
23757 
        oprot.writeI64(kiter561)
23758 
        oprot.writeString(viter562)
4600 varun.gupt 23759 
      oprot.writeMapEnd()
23760 
      oprot.writeFieldEnd()
23761 
    if self.ex is not None:
23762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23763 
      self.ex.write(oprot)
23764 
      oprot.writeFieldEnd()
23765 
    oprot.writeFieldStop()
23766 
    oprot.writeStructEnd()
23767 
 
23768 
  def validate(self):
23769 
    return
23770 
 
23771 
 
23772 
  def __repr__(self):
23773 
    L = ['%s=%r' % (key, value)
23774 
      for key, value in self.__dict__.iteritems()]
23775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23776 
 
23777 
  def __eq__(self, other):
23778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23779 
 
23780 
  def __ne__(self, other):
23781 
    return not (self == other)
23782 
 
23783 
class markEBSSettlementUploaded_args:
23784 
  """
23785 
  Attributes:
23786 
   - settlementId
23787 
  """
23788 
 
23789 
  thrift_spec = (
23790 
    None, # 0
23791 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23792 
  )
23793 
 
23794 
  def __init__(self, settlementId=None,):
23795 
    self.settlementId = settlementId
23796 
 
23797 
  def read(self, iprot):
23798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23800 
      return
23801 
    iprot.readStructBegin()
23802 
    while True:
23803 
      (fname, ftype, fid) = iprot.readFieldBegin()
23804 
      if ftype == TType.STOP:
23805 
        break
23806 
      if fid == 1:
23807 
        if ftype == TType.I64:
23808 
          self.settlementId = iprot.readI64();
23809 
        else:
23810 
          iprot.skip(ftype)
23811 
      else:
23812 
        iprot.skip(ftype)
23813 
      iprot.readFieldEnd()
23814 
    iprot.readStructEnd()
23815 
 
23816 
  def write(self, oprot):
23817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23819 
      return
23820 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23821 
    if self.settlementId is not None:
23822 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23823 
      oprot.writeI64(self.settlementId)
23824 
      oprot.writeFieldEnd()
23825 
    oprot.writeFieldStop()
23826 
    oprot.writeStructEnd()
23827 
 
23828 
  def validate(self):
23829 
    return
23830 
 
23831 
 
23832 
  def __repr__(self):
23833 
    L = ['%s=%r' % (key, value)
23834 
      for key, value in self.__dict__.iteritems()]
23835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23836 
 
23837 
  def __eq__(self, other):
23838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23839 
 
23840 
  def __ne__(self, other):
23841 
    return not (self == other)
23842 
 
23843 
class markEBSSettlementUploaded_result:
23844 
  """
23845 
  Attributes:
23846 
   - ex
23847 
  """
23848 
 
23849 
  thrift_spec = (
23850 
    None, # 0
23851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23852 
  )
23853 
 
23854 
  def __init__(self, ex=None,):
23855 
    self.ex = ex
23856 
 
23857 
  def read(self, iprot):
23858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23860 
      return
23861 
    iprot.readStructBegin()
23862 
    while True:
23863 
      (fname, ftype, fid) = iprot.readFieldBegin()
23864 
      if ftype == TType.STOP:
23865 
        break
23866 
      if fid == 1:
23867 
        if ftype == TType.STRUCT:
23868 
          self.ex = TransactionServiceException()
23869 
          self.ex.read(iprot)
23870 
        else:
23871 
          iprot.skip(ftype)
23872 
      else:
23873 
        iprot.skip(ftype)
23874 
      iprot.readFieldEnd()
23875 
    iprot.readStructEnd()
23876 
 
23877 
  def write(self, oprot):
23878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23880 
      return
23881 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23882 
    if self.ex is not None:
23883 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23884 
      self.ex.write(oprot)
23885 
      oprot.writeFieldEnd()
23886 
    oprot.writeFieldStop()
23887 
    oprot.writeStructEnd()
23888 
 
23889 
  def validate(self):
23890 
    return
23891 
 
23892 
 
23893 
  def __repr__(self):
23894 
    L = ['%s=%r' % (key, value)
23895 
      for key, value in self.__dict__.iteritems()]
23896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23897 
 
23898 
  def __eq__(self, other):
23899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23900 
 
23901 
  def __ne__(self, other):
23902 
    return not (self == other)
23903 
 
23904 
class getEBSSettlementDate_args:
23905 
  """
23906 
  Attributes:
23907 
   - settlementId
23908 
  """
23909 
 
23910 
  thrift_spec = (
23911 
    None, # 0
23912 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23913 
  )
23914 
 
23915 
  def __init__(self, settlementId=None,):
23916 
    self.settlementId = settlementId
23917 
 
23918 
  def read(self, iprot):
23919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23921 
      return
23922 
    iprot.readStructBegin()
23923 
    while True:
23924 
      (fname, ftype, fid) = iprot.readFieldBegin()
23925 
      if ftype == TType.STOP:
23926 
        break
23927 
      if fid == 1:
23928 
        if ftype == TType.I64:
23929 
          self.settlementId = iprot.readI64();
23930 
        else:
23931 
          iprot.skip(ftype)
23932 
      else:
23933 
        iprot.skip(ftype)
23934 
      iprot.readFieldEnd()
23935 
    iprot.readStructEnd()
23936 
 
23937 
  def write(self, oprot):
23938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23940 
      return
23941 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23942 
    if self.settlementId is not None:
23943 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23944 
      oprot.writeI64(self.settlementId)
23945 
      oprot.writeFieldEnd()
23946 
    oprot.writeFieldStop()
23947 
    oprot.writeStructEnd()
23948 
 
23949 
  def validate(self):
23950 
    return
23951 
 
23952 
 
23953 
  def __repr__(self):
23954 
    L = ['%s=%r' % (key, value)
23955 
      for key, value in self.__dict__.iteritems()]
23956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23957 
 
23958 
  def __eq__(self, other):
23959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23960 
 
23961 
  def __ne__(self, other):
23962 
    return not (self == other)
23963 
 
23964 
class getEBSSettlementDate_result:
23965 
  """
23966 
  Attributes:
23967 
   - success
23968 
   - ex
23969 
  """
23970 
 
23971 
  thrift_spec = (
23972 
    (0, TType.I64, 'success', None, None, ), # 0
23973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23974 
  )
23975 
 
23976 
  def __init__(self, success=None, ex=None,):
23977 
    self.success = success
23978 
    self.ex = ex
23979 
 
23980 
  def read(self, iprot):
23981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23983 
      return
23984 
    iprot.readStructBegin()
23985 
    while True:
23986 
      (fname, ftype, fid) = iprot.readFieldBegin()
23987 
      if ftype == TType.STOP:
23988 
        break
23989 
      if fid == 0:
23990 
        if ftype == TType.I64:
23991 
          self.success = iprot.readI64();
23992 
        else:
23993 
          iprot.skip(ftype)
23994 
      elif fid == 1:
23995 
        if ftype == TType.STRUCT:
23996 
          self.ex = TransactionServiceException()
23997 
          self.ex.read(iprot)
23998 
        else:
23999 
          iprot.skip(ftype)
24000 
      else:
24001 
        iprot.skip(ftype)
24002 
      iprot.readFieldEnd()
24003 
    iprot.readStructEnd()
24004 
 
24005 
  def write(self, oprot):
24006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24008 
      return
24009 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24010 
    if self.success is not None:
24011 
      oprot.writeFieldBegin('success', TType.I64, 0)
24012 
      oprot.writeI64(self.success)
24013 
      oprot.writeFieldEnd()
24014 
    if self.ex is not None:
24015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24016 
      self.ex.write(oprot)
24017 
      oprot.writeFieldEnd()
24018 
    oprot.writeFieldStop()
24019 
    oprot.writeStructEnd()
24020 
 
24021 
  def validate(self):
24022 
    return
24023 
 
24024 
 
24025 
  def __repr__(self):
24026 
    L = ['%s=%r' % (key, value)
24027 
      for key, value in self.__dict__.iteritems()]
24028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24029 
 
24030 
  def __eq__(self, other):
24031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24032 
 
24033 
  def __ne__(self, other):
24034 
    return not (self == other)
4715 varun.gupt 24035 
 
24036 
class getSettlementsByDate_args:
24037 
  """
24038 
  Attributes:
24039 
   - settlementDateFrom
24040 
   - settlementDateTo
24041 
   - isRefund
24042 
  """
24043 
 
24044 
  thrift_spec = (
24045 
    None, # 0
24046 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24047 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24048 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24049 
  )
24050 
 
24051 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24052 
    self.settlementDateFrom = settlementDateFrom
24053 
    self.settlementDateTo = settlementDateTo
24054 
    self.isRefund = isRefund
24055 
 
24056 
  def read(self, iprot):
24057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24059 
      return
24060 
    iprot.readStructBegin()
24061 
    while True:
24062 
      (fname, ftype, fid) = iprot.readFieldBegin()
24063 
      if ftype == TType.STOP:
24064 
        break
24065 
      if fid == 1:
24066 
        if ftype == TType.I64:
24067 
          self.settlementDateFrom = iprot.readI64();
24068 
        else:
24069 
          iprot.skip(ftype)
24070 
      elif fid == 2:
24071 
        if ftype == TType.I64:
24072 
          self.settlementDateTo = iprot.readI64();
24073 
        else:
24074 
          iprot.skip(ftype)
24075 
      elif fid == 3:
24076 
        if ftype == TType.BOOL:
24077 
          self.isRefund = iprot.readBool();
24078 
        else:
24079 
          iprot.skip(ftype)
24080 
      else:
24081 
        iprot.skip(ftype)
24082 
      iprot.readFieldEnd()
24083 
    iprot.readStructEnd()
24084 
 
24085 
  def write(self, oprot):
24086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24088 
      return
24089 
    oprot.writeStructBegin('getSettlementsByDate_args')
24090 
    if self.settlementDateFrom is not None:
24091 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24092 
      oprot.writeI64(self.settlementDateFrom)
24093 
      oprot.writeFieldEnd()
24094 
    if self.settlementDateTo is not None:
24095 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24096 
      oprot.writeI64(self.settlementDateTo)
24097 
      oprot.writeFieldEnd()
24098 
    if self.isRefund is not None:
24099 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24100 
      oprot.writeBool(self.isRefund)
24101 
      oprot.writeFieldEnd()
24102 
    oprot.writeFieldStop()
24103 
    oprot.writeStructEnd()
24104 
 
24105 
  def validate(self):
24106 
    return
24107 
 
24108 
 
24109 
  def __repr__(self):
24110 
    L = ['%s=%r' % (key, value)
24111 
      for key, value in self.__dict__.iteritems()]
24112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24113 
 
24114 
  def __eq__(self, other):
24115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24116 
 
24117 
  def __ne__(self, other):
24118 
    return not (self == other)
24119 
 
24120 
class getSettlementsByDate_result:
24121 
  """
24122 
  Attributes:
24123 
   - success
24124 
   - ex
24125 
  """
24126 
 
24127 
  thrift_spec = (
24128 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24130 
  )
24131 
 
24132 
  def __init__(self, success=None, ex=None,):
24133 
    self.success = success
24134 
    self.ex = ex
24135 
 
24136 
  def read(self, iprot):
24137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24139 
      return
24140 
    iprot.readStructBegin()
24141 
    while True:
24142 
      (fname, ftype, fid) = iprot.readFieldBegin()
24143 
      if ftype == TType.STOP:
24144 
        break
24145 
      if fid == 0:
24146 
        if ftype == TType.LIST:
24147 
          self.success = []
6188 rajveer 24148 
          (_etype566, _size563) = iprot.readListBegin()
24149 
          for _i567 in xrange(_size563):
24150 
            _elem568 = PaymentSettlement()
24151 
            _elem568.read(iprot)
24152 
            self.success.append(_elem568)
4715 varun.gupt 24153 
          iprot.readListEnd()
24154 
        else:
24155 
          iprot.skip(ftype)
24156 
      elif fid == 1:
24157 
        if ftype == TType.STRUCT:
24158 
          self.ex = TransactionServiceException()
24159 
          self.ex.read(iprot)
24160 
        else:
24161 
          iprot.skip(ftype)
24162 
      else:
24163 
        iprot.skip(ftype)
24164 
      iprot.readFieldEnd()
24165 
    iprot.readStructEnd()
24166 
 
24167 
  def write(self, oprot):
24168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24170 
      return
24171 
    oprot.writeStructBegin('getSettlementsByDate_result')
24172 
    if self.success is not None:
24173 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24174 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24175 
      for iter569 in self.success:
24176 
        iter569.write(oprot)
4715 varun.gupt 24177 
      oprot.writeListEnd()
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)
24200 
 
24201 
class getReshippedOrderIds_args:
24202 
  """
24203 
  Attributes:
24204 
   - orderIds
24205 
  """
24206 
 
24207 
  thrift_spec = (
24208 
    None, # 0
24209 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24210 
  )
24211 
 
24212 
  def __init__(self, orderIds=None,):
24213 
    self.orderIds = orderIds
24214 
 
24215 
  def read(self, iprot):
24216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24218 
      return
24219 
    iprot.readStructBegin()
24220 
    while True:
24221 
      (fname, ftype, fid) = iprot.readFieldBegin()
24222 
      if ftype == TType.STOP:
24223 
        break
24224 
      if fid == 1:
24225 
        if ftype == TType.LIST:
24226 
          self.orderIds = []
6188 rajveer 24227 
          (_etype573, _size570) = iprot.readListBegin()
24228 
          for _i574 in xrange(_size570):
24229 
            _elem575 = iprot.readI64();
24230 
            self.orderIds.append(_elem575)
4715 varun.gupt 24231 
          iprot.readListEnd()
24232 
        else:
24233 
          iprot.skip(ftype)
24234 
      else:
24235 
        iprot.skip(ftype)
24236 
      iprot.readFieldEnd()
24237 
    iprot.readStructEnd()
24238 
 
24239 
  def write(self, oprot):
24240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24242 
      return
24243 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24244 
    if self.orderIds is not None:
24245 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24246 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24247 
      for iter576 in self.orderIds:
24248 
        oprot.writeI64(iter576)
4715 varun.gupt 24249 
      oprot.writeListEnd()
24250 
      oprot.writeFieldEnd()
24251 
    oprot.writeFieldStop()
24252 
    oprot.writeStructEnd()
24253 
 
24254 
  def validate(self):
24255 
    return
24256 
 
24257 
 
24258 
  def __repr__(self):
24259 
    L = ['%s=%r' % (key, value)
24260 
      for key, value in self.__dict__.iteritems()]
24261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24262 
 
24263 
  def __eq__(self, other):
24264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24265 
 
24266 
  def __ne__(self, other):
24267 
    return not (self == other)
24268 
 
24269 
class getReshippedOrderIds_result:
24270 
  """
24271 
  Attributes:
24272 
   - success
24273 
   - ex
24274 
  """
24275 
 
24276 
  thrift_spec = (
24277 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24278 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24279 
  )
24280 
 
24281 
  def __init__(self, success=None, ex=None,):
24282 
    self.success = success
24283 
    self.ex = ex
24284 
 
24285 
  def read(self, iprot):
24286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24288 
      return
24289 
    iprot.readStructBegin()
24290 
    while True:
24291 
      (fname, ftype, fid) = iprot.readFieldBegin()
24292 
      if ftype == TType.STOP:
24293 
        break
24294 
      if fid == 0:
24295 
        if ftype == TType.LIST:
24296 
          self.success = []
6188 rajveer 24297 
          (_etype580, _size577) = iprot.readListBegin()
24298 
          for _i581 in xrange(_size577):
24299 
            _elem582 = iprot.readI64();
24300 
            self.success.append(_elem582)
4715 varun.gupt 24301 
          iprot.readListEnd()
24302 
        else:
24303 
          iprot.skip(ftype)
24304 
      elif fid == 1:
24305 
        if ftype == TType.STRUCT:
24306 
          self.ex = TransactionServiceException()
24307 
          self.ex.read(iprot)
24308 
        else:
24309 
          iprot.skip(ftype)
24310 
      else:
24311 
        iprot.skip(ftype)
24312 
      iprot.readFieldEnd()
24313 
    iprot.readStructEnd()
24314 
 
24315 
  def write(self, oprot):
24316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24318 
      return
24319 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24320 
    if self.success is not None:
24321 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24322 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24323 
      for iter583 in self.success:
24324 
        oprot.writeI64(iter583)
4715 varun.gupt 24325 
      oprot.writeListEnd()
24326 
      oprot.writeFieldEnd()
24327 
    if self.ex is not None:
24328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24329 
      self.ex.write(oprot)
24330 
      oprot.writeFieldEnd()
24331 
    oprot.writeFieldStop()
24332 
    oprot.writeStructEnd()
24333 
 
24334 
  def validate(self):
24335 
    return
24336 
 
24337 
 
24338 
  def __repr__(self):
24339 
    L = ['%s=%r' % (key, value)
24340 
      for key, value in self.__dict__.iteritems()]
24341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24342 
 
24343 
  def __eq__(self, other):
24344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24345 
 
24346 
  def __ne__(self, other):
24347 
    return not (self == other)
4757 mandeep.dh 24348 
 
5481 phani.kuma 24349 
class getBilledOrders_args:
4875 varun.gupt 24350 
  """
24351 
  Attributes:
24352 
   - vendorId
5481 phani.kuma 24353 
   - onlyVendorNotPaid
24354 
   - billingDateFrom
24355 
   - billingDateTo
4875 varun.gupt 24356 
  """
24357 
 
24358 
  thrift_spec = (
24359 
    None, # 0
24360 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24361 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24362 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24363 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24364 
  )
24365 
 
5481 phani.kuma 24366 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24367 
    self.vendorId = vendorId
5481 phani.kuma 24368 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24369 
    self.billingDateFrom = billingDateFrom
24370 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24371 
 
24372 
  def read(self, iprot):
24373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24375 
      return
24376 
    iprot.readStructBegin()
24377 
    while True:
24378 
      (fname, ftype, fid) = iprot.readFieldBegin()
24379 
      if ftype == TType.STOP:
24380 
        break
24381 
      if fid == 1:
24382 
        if ftype == TType.I64:
24383 
          self.vendorId = iprot.readI64();
24384 
        else:
24385 
          iprot.skip(ftype)
5481 phani.kuma 24386 
      elif fid == 2:
24387 
        if ftype == TType.BOOL:
24388 
          self.onlyVendorNotPaid = iprot.readBool();
24389 
        else:
24390 
          iprot.skip(ftype)
24391 
      elif fid == 3:
24392 
        if ftype == TType.I64:
24393 
          self.billingDateFrom = iprot.readI64();
24394 
        else:
24395 
          iprot.skip(ftype)
24396 
      elif fid == 4:
24397 
        if ftype == TType.I64:
24398 
          self.billingDateTo = iprot.readI64();
24399 
        else:
24400 
          iprot.skip(ftype)
4875 varun.gupt 24401 
      else:
24402 
        iprot.skip(ftype)
24403 
      iprot.readFieldEnd()
24404 
    iprot.readStructEnd()
24405 
 
24406 
  def write(self, oprot):
24407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24409 
      return
5481 phani.kuma 24410 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24411 
    if self.vendorId is not None:
24412 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24413 
      oprot.writeI64(self.vendorId)
24414 
      oprot.writeFieldEnd()
5481 phani.kuma 24415 
    if self.onlyVendorNotPaid is not None:
24416 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24417 
      oprot.writeBool(self.onlyVendorNotPaid)
24418 
      oprot.writeFieldEnd()
24419 
    if self.billingDateFrom is not None:
24420 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24421 
      oprot.writeI64(self.billingDateFrom)
24422 
      oprot.writeFieldEnd()
24423 
    if self.billingDateTo is not None:
24424 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24425 
      oprot.writeI64(self.billingDateTo)
24426 
      oprot.writeFieldEnd()
4875 varun.gupt 24427 
    oprot.writeFieldStop()
24428 
    oprot.writeStructEnd()
24429 
 
24430 
  def validate(self):
24431 
    return
24432 
 
24433 
 
24434 
  def __repr__(self):
24435 
    L = ['%s=%r' % (key, value)
24436 
      for key, value in self.__dict__.iteritems()]
24437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24438 
 
24439 
  def __eq__(self, other):
24440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24441 
 
24442 
  def __ne__(self, other):
24443 
    return not (self == other)
24444 
 
5481 phani.kuma 24445 
class getBilledOrders_result:
4875 varun.gupt 24446 
  """
24447 
  Attributes:
24448 
   - success
24449 
   - ex
24450 
  """
24451 
 
24452 
  thrift_spec = (
24453 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24454 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24455 
  )
24456 
 
24457 
  def __init__(self, success=None, ex=None,):
24458 
    self.success = success
24459 
    self.ex = ex
24460 
 
24461 
  def read(self, iprot):
24462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24464 
      return
24465 
    iprot.readStructBegin()
24466 
    while True:
24467 
      (fname, ftype, fid) = iprot.readFieldBegin()
24468 
      if ftype == TType.STOP:
24469 
        break
24470 
      if fid == 0:
24471 
        if ftype == TType.LIST:
24472 
          self.success = []
6188 rajveer 24473 
          (_etype587, _size584) = iprot.readListBegin()
24474 
          for _i588 in xrange(_size584):
24475 
            _elem589 = Order()
24476 
            _elem589.read(iprot)
24477 
            self.success.append(_elem589)
4875 varun.gupt 24478 
          iprot.readListEnd()
24479 
        else:
24480 
          iprot.skip(ftype)
24481 
      elif fid == 1:
24482 
        if ftype == TType.STRUCT:
24483 
          self.ex = TransactionServiceException()
24484 
          self.ex.read(iprot)
24485 
        else:
24486 
          iprot.skip(ftype)
24487 
      else:
24488 
        iprot.skip(ftype)
24489 
      iprot.readFieldEnd()
24490 
    iprot.readStructEnd()
24491 
 
24492 
  def write(self, oprot):
24493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24495 
      return
5481 phani.kuma 24496 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24497 
    if self.success is not None:
24498 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24499 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24500 
      for iter590 in self.success:
24501 
        iter590.write(oprot)
4875 varun.gupt 24502 
      oprot.writeListEnd()
24503 
      oprot.writeFieldEnd()
24504 
    if self.ex is not None:
24505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24506 
      self.ex.write(oprot)
24507 
      oprot.writeFieldEnd()
24508 
    oprot.writeFieldStop()
24509 
    oprot.writeStructEnd()
24510 
 
24511 
  def validate(self):
24512 
    return
24513 
 
24514 
 
24515 
  def __repr__(self):
24516 
    L = ['%s=%r' % (key, value)
24517 
      for key, value in self.__dict__.iteritems()]
24518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24519 
 
24520 
  def __eq__(self, other):
24521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24522 
 
24523 
  def __ne__(self, other):
24524 
    return not (self == other)
5031 varun.gupt 24525 
 
24526 
class getStatusDistributionOfOrders_args:
24527 
  """
24528 
  Attributes:
24529 
   - startDate
24530 
   - endDate
24531 
  """
24532 
 
24533 
  thrift_spec = (
24534 
    None, # 0
24535 
    (1, TType.I64, 'startDate', None, None, ), # 1
24536 
    (2, TType.I64, 'endDate', None, None, ), # 2
24537 
  )
24538 
 
24539 
  def __init__(self, startDate=None, endDate=None,):
24540 
    self.startDate = startDate
24541 
    self.endDate = endDate
24542 
 
24543 
  def read(self, iprot):
24544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24546 
      return
24547 
    iprot.readStructBegin()
24548 
    while True:
24549 
      (fname, ftype, fid) = iprot.readFieldBegin()
24550 
      if ftype == TType.STOP:
24551 
        break
24552 
      if fid == 1:
24553 
        if ftype == TType.I64:
24554 
          self.startDate = iprot.readI64();
24555 
        else:
24556 
          iprot.skip(ftype)
24557 
      elif fid == 2:
24558 
        if ftype == TType.I64:
24559 
          self.endDate = iprot.readI64();
24560 
        else:
24561 
          iprot.skip(ftype)
24562 
      else:
24563 
        iprot.skip(ftype)
24564 
      iprot.readFieldEnd()
24565 
    iprot.readStructEnd()
24566 
 
24567 
  def write(self, oprot):
24568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24570 
      return
24571 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24572 
    if self.startDate is not None:
24573 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24574 
      oprot.writeI64(self.startDate)
24575 
      oprot.writeFieldEnd()
24576 
    if self.endDate is not None:
24577 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24578 
      oprot.writeI64(self.endDate)
24579 
      oprot.writeFieldEnd()
24580 
    oprot.writeFieldStop()
24581 
    oprot.writeStructEnd()
24582 
 
24583 
  def validate(self):
24584 
    return
24585 
 
24586 
 
24587 
  def __repr__(self):
24588 
    L = ['%s=%r' % (key, value)
24589 
      for key, value in self.__dict__.iteritems()]
24590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24591 
 
24592 
  def __eq__(self, other):
24593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24594 
 
24595 
  def __ne__(self, other):
24596 
    return not (self == other)
24597 
 
24598 
class getStatusDistributionOfOrders_result:
24599 
  """
24600 
  Attributes:
24601 
   - success
24602 
   - ex
24603 
  """
24604 
 
24605 
  thrift_spec = (
24606 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24608 
  )
24609 
 
24610 
  def __init__(self, success=None, ex=None,):
24611 
    self.success = success
24612 
    self.ex = ex
24613 
 
24614 
  def read(self, iprot):
24615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24617 
      return
24618 
    iprot.readStructBegin()
24619 
    while True:
24620 
      (fname, ftype, fid) = iprot.readFieldBegin()
24621 
      if ftype == TType.STOP:
24622 
        break
24623 
      if fid == 0:
24624 
        if ftype == TType.MAP:
24625 
          self.success = {}
6188 rajveer 24626 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24627 
          for _i595 in xrange(_size591):
24628 
            _key596 = iprot.readI64();
24629 
            _val597 = iprot.readI64();
24630 
            self.success[_key596] = _val597
5031 varun.gupt 24631 
          iprot.readMapEnd()
24632 
        else:
24633 
          iprot.skip(ftype)
24634 
      elif fid == 1:
24635 
        if ftype == TType.STRUCT:
24636 
          self.ex = TransactionServiceException()
24637 
          self.ex.read(iprot)
24638 
        else:
24639 
          iprot.skip(ftype)
24640 
      else:
24641 
        iprot.skip(ftype)
24642 
      iprot.readFieldEnd()
24643 
    iprot.readStructEnd()
24644 
 
24645 
  def write(self, oprot):
24646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24648 
      return
24649 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24650 
    if self.success is not None:
24651 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24652 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24653 
      for kiter598,viter599 in self.success.items():
24654 
        oprot.writeI64(kiter598)
24655 
        oprot.writeI64(viter599)
5031 varun.gupt 24656 
      oprot.writeMapEnd()
24657 
      oprot.writeFieldEnd()
24658 
    if self.ex is not None:
24659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24660 
      self.ex.write(oprot)
24661 
      oprot.writeFieldEnd()
24662 
    oprot.writeFieldStop()
24663 
    oprot.writeStructEnd()
24664 
 
24665 
  def validate(self):
24666 
    return
24667 
 
24668 
 
24669 
  def __repr__(self):
24670 
    L = ['%s=%r' % (key, value)
24671 
      for key, value in self.__dict__.iteritems()]
24672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24673 
 
24674 
  def __eq__(self, other):
24675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24676 
 
24677 
  def __ne__(self, other):
24678 
    return not (self == other)
5067 varun.gupt 24679 
 
24680 
class getOrderIdsForStatus_args:
24681 
  """
24682 
  Attributes:
24683 
   - status
24684 
   - startDatetime
24685 
   - endDatetime
24686 
  """
24687 
 
24688 
  thrift_spec = (
24689 
    None, # 0
24690 
    (1, TType.I64, 'status', None, None, ), # 1
24691 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24692 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24693 
  )
24694 
 
24695 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24696 
    self.status = status
24697 
    self.startDatetime = startDatetime
24698 
    self.endDatetime = endDatetime
24699 
 
24700 
  def read(self, iprot):
24701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24703 
      return
24704 
    iprot.readStructBegin()
24705 
    while True:
24706 
      (fname, ftype, fid) = iprot.readFieldBegin()
24707 
      if ftype == TType.STOP:
24708 
        break
24709 
      if fid == 1:
24710 
        if ftype == TType.I64:
24711 
          self.status = iprot.readI64();
24712 
        else:
24713 
          iprot.skip(ftype)
24714 
      elif fid == 2:
24715 
        if ftype == TType.I64:
24716 
          self.startDatetime = iprot.readI64();
24717 
        else:
24718 
          iprot.skip(ftype)
24719 
      elif fid == 3:
24720 
        if ftype == TType.I64:
24721 
          self.endDatetime = iprot.readI64();
24722 
        else:
24723 
          iprot.skip(ftype)
24724 
      else:
24725 
        iprot.skip(ftype)
24726 
      iprot.readFieldEnd()
24727 
    iprot.readStructEnd()
24728 
 
24729 
  def write(self, oprot):
24730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24732 
      return
24733 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24734 
    if self.status is not None:
24735 
      oprot.writeFieldBegin('status', TType.I64, 1)
24736 
      oprot.writeI64(self.status)
24737 
      oprot.writeFieldEnd()
24738 
    if self.startDatetime is not None:
24739 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24740 
      oprot.writeI64(self.startDatetime)
24741 
      oprot.writeFieldEnd()
24742 
    if self.endDatetime is not None:
24743 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24744 
      oprot.writeI64(self.endDatetime)
24745 
      oprot.writeFieldEnd()
24746 
    oprot.writeFieldStop()
24747 
    oprot.writeStructEnd()
24748 
 
24749 
  def validate(self):
24750 
    return
24751 
 
24752 
 
24753 
  def __repr__(self):
24754 
    L = ['%s=%r' % (key, value)
24755 
      for key, value in self.__dict__.iteritems()]
24756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24757 
 
24758 
  def __eq__(self, other):
24759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24760 
 
24761 
  def __ne__(self, other):
24762 
    return not (self == other)
24763 
 
24764 
class getOrderIdsForStatus_result:
24765 
  """
24766 
  Attributes:
24767 
   - success
24768 
   - ex
24769 
  """
24770 
 
24771 
  thrift_spec = (
24772 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24774 
  )
24775 
 
24776 
  def __init__(self, success=None, ex=None,):
24777 
    self.success = success
24778 
    self.ex = ex
24779 
 
24780 
  def read(self, iprot):
24781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24783 
      return
24784 
    iprot.readStructBegin()
24785 
    while True:
24786 
      (fname, ftype, fid) = iprot.readFieldBegin()
24787 
      if ftype == TType.STOP:
24788 
        break
24789 
      if fid == 0:
24790 
        if ftype == TType.LIST:
24791 
          self.success = []
6188 rajveer 24792 
          (_etype603, _size600) = iprot.readListBegin()
24793 
          for _i604 in xrange(_size600):
24794 
            _elem605 = iprot.readI64();
24795 
            self.success.append(_elem605)
5067 varun.gupt 24796 
          iprot.readListEnd()
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('getOrderIdsForStatus_result')
24815 
    if self.success is not None:
24816 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24817 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24818 
      for iter606 in self.success:
24819 
        oprot.writeI64(iter606)
5067 varun.gupt 24820 
      oprot.writeListEnd()
24821 
      oprot.writeFieldEnd()
24822 
    if self.ex is not None:
24823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24824 
      self.ex.write(oprot)
24825 
      oprot.writeFieldEnd()
24826 
    oprot.writeFieldStop()
24827 
    oprot.writeStructEnd()
24828 
 
24829 
  def validate(self):
24830 
    return
24831 
 
24832 
 
24833 
  def __repr__(self):
24834 
    L = ['%s=%r' % (key, value)
24835 
      for key, value in self.__dict__.iteritems()]
24836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24837 
 
24838 
  def __eq__(self, other):
24839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24840 
 
24841 
  def __ne__(self, other):
24842 
    return not (self == other)
5099 varun.gupt 24843 
 
5348 anupam.sin 24844 
class updateCODAgent_args:
24845 
  """
24846 
  Attributes:
24847 
   - agent
24848 
   - orderId
24849 
  """
24850 
 
24851 
  thrift_spec = (
24852 
    None, # 0
24853 
    (1, TType.STRING, 'agent', None, None, ), # 1
24854 
    (2, TType.I64, 'orderId', None, None, ), # 2
24855 
  )
24856 
 
24857 
  def __init__(self, agent=None, orderId=None,):
24858 
    self.agent = agent
24859 
    self.orderId = orderId
24860 
 
24861 
  def read(self, iprot):
24862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24864 
      return
24865 
    iprot.readStructBegin()
24866 
    while True:
24867 
      (fname, ftype, fid) = iprot.readFieldBegin()
24868 
      if ftype == TType.STOP:
24869 
        break
24870 
      if fid == 1:
24871 
        if ftype == TType.STRING:
24872 
          self.agent = iprot.readString();
24873 
        else:
24874 
          iprot.skip(ftype)
24875 
      elif fid == 2:
24876 
        if ftype == TType.I64:
24877 
          self.orderId = iprot.readI64();
24878 
        else:
24879 
          iprot.skip(ftype)
24880 
      else:
24881 
        iprot.skip(ftype)
24882 
      iprot.readFieldEnd()
24883 
    iprot.readStructEnd()
24884 
 
24885 
  def write(self, oprot):
24886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24888 
      return
24889 
    oprot.writeStructBegin('updateCODAgent_args')
24890 
    if self.agent is not None:
24891 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24892 
      oprot.writeString(self.agent)
24893 
      oprot.writeFieldEnd()
24894 
    if self.orderId is not None:
24895 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24896 
      oprot.writeI64(self.orderId)
24897 
      oprot.writeFieldEnd()
24898 
    oprot.writeFieldStop()
24899 
    oprot.writeStructEnd()
24900 
 
24901 
  def validate(self):
24902 
    return
24903 
 
24904 
 
24905 
  def __repr__(self):
24906 
    L = ['%s=%r' % (key, value)
24907 
      for key, value in self.__dict__.iteritems()]
24908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24909 
 
24910 
  def __eq__(self, other):
24911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24912 
 
24913 
  def __ne__(self, other):
24914 
    return not (self == other)
24915 
 
24916 
class updateCODAgent_result:
24917 
  """
24918 
  Attributes:
24919 
   - ex
24920 
  """
24921 
 
24922 
  thrift_spec = (
24923 
    None, # 0
24924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24925 
  )
24926 
 
24927 
  def __init__(self, ex=None,):
24928 
    self.ex = ex
24929 
 
24930 
  def read(self, iprot):
24931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24933 
      return
24934 
    iprot.readStructBegin()
24935 
    while True:
24936 
      (fname, ftype, fid) = iprot.readFieldBegin()
24937 
      if ftype == TType.STOP:
24938 
        break
24939 
      if fid == 1:
24940 
        if ftype == TType.STRUCT:
24941 
          self.ex = TransactionServiceException()
24942 
          self.ex.read(iprot)
24943 
        else:
24944 
          iprot.skip(ftype)
24945 
      else:
24946 
        iprot.skip(ftype)
24947 
      iprot.readFieldEnd()
24948 
    iprot.readStructEnd()
24949 
 
24950 
  def write(self, oprot):
24951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24953 
      return
24954 
    oprot.writeStructBegin('updateCODAgent_result')
24955 
    if self.ex is not None:
24956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24957 
      self.ex.write(oprot)
24958 
      oprot.writeFieldEnd()
24959 
    oprot.writeFieldStop()
24960 
    oprot.writeStructEnd()
24961 
 
24962 
  def validate(self):
24963 
    return
24964 
 
24965 
 
24966 
  def __repr__(self):
24967 
    L = ['%s=%r' % (key, value)
24968 
      for key, value in self.__dict__.iteritems()]
24969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24970 
 
24971 
  def __eq__(self, other):
24972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24973 
 
24974 
  def __ne__(self, other):
24975 
    return not (self == other)
24976 
 
5099 varun.gupt 24977 
class updateOrderAsPaidToVendor_args:
24978 
  """
24979 
  Attributes:
24980 
   - orderId
24981 
  """
24982 
 
24983 
  thrift_spec = (
24984 
    None, # 0
24985 
    (1, TType.I64, 'orderId', None, None, ), # 1
24986 
  )
24987 
 
24988 
  def __init__(self, orderId=None,):
24989 
    self.orderId = orderId
24990 
 
24991 
  def read(self, iprot):
24992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24994 
      return
24995 
    iprot.readStructBegin()
24996 
    while True:
24997 
      (fname, ftype, fid) = iprot.readFieldBegin()
24998 
      if ftype == TType.STOP:
24999 
        break
25000 
      if fid == 1:
25001 
        if ftype == TType.I64:
25002 
          self.orderId = iprot.readI64();
25003 
        else:
25004 
          iprot.skip(ftype)
25005 
      else:
25006 
        iprot.skip(ftype)
25007 
      iprot.readFieldEnd()
25008 
    iprot.readStructEnd()
25009 
 
25010 
  def write(self, oprot):
25011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25013 
      return
25014 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25015 
    if self.orderId is not None:
25016 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25017 
      oprot.writeI64(self.orderId)
25018 
      oprot.writeFieldEnd()
25019 
    oprot.writeFieldStop()
25020 
    oprot.writeStructEnd()
25021 
 
25022 
  def validate(self):
25023 
    return
25024 
 
25025 
 
25026 
  def __repr__(self):
25027 
    L = ['%s=%r' % (key, value)
25028 
      for key, value in self.__dict__.iteritems()]
25029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25030 
 
25031 
  def __eq__(self, other):
25032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25033 
 
25034 
  def __ne__(self, other):
25035 
    return not (self == other)
25036 
 
25037 
class updateOrderAsPaidToVendor_result:
25038 
  """
25039 
  Attributes:
25040 
   - ex
25041 
  """
25042 
 
25043 
  thrift_spec = (
25044 
    None, # 0
25045 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25046 
  )
25047 
 
25048 
  def __init__(self, ex=None,):
25049 
    self.ex = ex
25050 
 
25051 
  def read(self, iprot):
25052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25054 
      return
25055 
    iprot.readStructBegin()
25056 
    while True:
25057 
      (fname, ftype, fid) = iprot.readFieldBegin()
25058 
      if ftype == TType.STOP:
25059 
        break
25060 
      if fid == 1:
25061 
        if ftype == TType.STRUCT:
25062 
          self.ex = TransactionServiceException()
25063 
          self.ex.read(iprot)
25064 
        else:
25065 
          iprot.skip(ftype)
25066 
      else:
25067 
        iprot.skip(ftype)
25068 
      iprot.readFieldEnd()
25069 
    iprot.readStructEnd()
25070 
 
25071 
  def write(self, oprot):
25072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25074 
      return
25075 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25076 
    if self.ex is not None:
25077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25078 
      self.ex.write(oprot)
25079 
      oprot.writeFieldEnd()
25080 
    oprot.writeFieldStop()
25081 
    oprot.writeStructEnd()
25082 
 
25083 
  def validate(self):
25084 
    return
25085 
 
25086 
 
25087 
  def __repr__(self):
25088 
    L = ['%s=%r' % (key, value)
25089 
      for key, value in self.__dict__.iteritems()]
25090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25091 
 
25092 
  def __eq__(self, other):
25093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25094 
 
25095 
  def __ne__(self, other):
25096 
    return not (self == other)
5208 varun.gupt 25097 
 
5386 phani.kuma 25098 
class updateOrderOnlyAsPaidToVendor_args:
25099 
  """
25100 
  Attributes:
25101 
   - orderId
25102 
  """
25103 
 
25104 
  thrift_spec = (
25105 
    None, # 0
25106 
    (1, TType.I64, 'orderId', None, None, ), # 1
25107 
  )
25108 
 
25109 
  def __init__(self, orderId=None,):
25110 
    self.orderId = orderId
25111 
 
25112 
  def read(self, iprot):
25113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25115 
      return
25116 
    iprot.readStructBegin()
25117 
    while True:
25118 
      (fname, ftype, fid) = iprot.readFieldBegin()
25119 
      if ftype == TType.STOP:
25120 
        break
25121 
      if fid == 1:
25122 
        if ftype == TType.I64:
25123 
          self.orderId = iprot.readI64();
25124 
        else:
25125 
          iprot.skip(ftype)
25126 
      else:
25127 
        iprot.skip(ftype)
25128 
      iprot.readFieldEnd()
25129 
    iprot.readStructEnd()
25130 
 
25131 
  def write(self, oprot):
25132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25134 
      return
25135 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25136 
    if self.orderId is not None:
25137 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25138 
      oprot.writeI64(self.orderId)
25139 
      oprot.writeFieldEnd()
25140 
    oprot.writeFieldStop()
25141 
    oprot.writeStructEnd()
25142 
 
25143 
  def validate(self):
25144 
    return
25145 
 
25146 
 
25147 
  def __repr__(self):
25148 
    L = ['%s=%r' % (key, value)
25149 
      for key, value in self.__dict__.iteritems()]
25150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25151 
 
25152 
  def __eq__(self, other):
25153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25154 
 
25155 
  def __ne__(self, other):
25156 
    return not (self == other)
25157 
 
25158 
class updateOrderOnlyAsPaidToVendor_result:
25159 
  """
25160 
  Attributes:
25161 
   - ex
25162 
  """
25163 
 
25164 
  thrift_spec = (
25165 
    None, # 0
25166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25167 
  )
25168 
 
25169 
  def __init__(self, ex=None,):
25170 
    self.ex = ex
25171 
 
25172 
  def read(self, iprot):
25173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25175 
      return
25176 
    iprot.readStructBegin()
25177 
    while True:
25178 
      (fname, ftype, fid) = iprot.readFieldBegin()
25179 
      if ftype == TType.STOP:
25180 
        break
25181 
      if fid == 1:
25182 
        if ftype == TType.STRUCT:
25183 
          self.ex = TransactionServiceException()
25184 
          self.ex.read(iprot)
25185 
        else:
25186 
          iprot.skip(ftype)
25187 
      else:
25188 
        iprot.skip(ftype)
25189 
      iprot.readFieldEnd()
25190 
    iprot.readStructEnd()
25191 
 
25192 
  def write(self, oprot):
25193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25195 
      return
25196 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25197 
    if self.ex is not None:
25198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25199 
      self.ex.write(oprot)
25200 
      oprot.writeFieldEnd()
25201 
    oprot.writeFieldStop()
25202 
    oprot.writeStructEnd()
25203 
 
25204 
  def validate(self):
25205 
    return
25206 
 
25207 
 
25208 
  def __repr__(self):
25209 
    L = ['%s=%r' % (key, value)
25210 
      for key, value in self.__dict__.iteritems()]
25211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25212 
 
25213 
  def __eq__(self, other):
25214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25215 
 
25216 
  def __ne__(self, other):
25217 
    return not (self == other)
25218 
 
5208 varun.gupt 25219 
class getRefundedOrdersMarkedPaid_args:
25220 
 
25221 
  thrift_spec = (
25222 
  )
25223 
 
25224 
  def read(self, iprot):
25225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25227 
      return
25228 
    iprot.readStructBegin()
25229 
    while True:
25230 
      (fname, ftype, fid) = iprot.readFieldBegin()
25231 
      if ftype == TType.STOP:
25232 
        break
25233 
      else:
25234 
        iprot.skip(ftype)
25235 
      iprot.readFieldEnd()
25236 
    iprot.readStructEnd()
25237 
 
25238 
  def write(self, oprot):
25239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25241 
      return
25242 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25243 
    oprot.writeFieldStop()
25244 
    oprot.writeStructEnd()
25245 
 
25246 
  def validate(self):
25247 
    return
25248 
 
25249 
 
25250 
  def __repr__(self):
25251 
    L = ['%s=%r' % (key, value)
25252 
      for key, value in self.__dict__.iteritems()]
25253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25254 
 
25255 
  def __eq__(self, other):
25256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25257 
 
25258 
  def __ne__(self, other):
25259 
    return not (self == other)
25260 
 
25261 
class getRefundedOrdersMarkedPaid_result:
25262 
  """
25263 
  Attributes:
25264 
   - success
25265 
   - ex
25266 
  """
25267 
 
25268 
  thrift_spec = (
25269 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25271 
  )
25272 
 
25273 
  def __init__(self, success=None, ex=None,):
25274 
    self.success = success
25275 
    self.ex = ex
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 == 0:
25287 
        if ftype == TType.LIST:
25288 
          self.success = []
6188 rajveer 25289 
          (_etype610, _size607) = iprot.readListBegin()
25290 
          for _i611 in xrange(_size607):
25291 
            _elem612 = Order()
25292 
            _elem612.read(iprot)
25293 
            self.success.append(_elem612)
5208 varun.gupt 25294 
          iprot.readListEnd()
25295 
        else:
25296 
          iprot.skip(ftype)
25297 
      elif fid == 1:
25298 
        if ftype == TType.STRUCT:
25299 
          self.ex = TransactionServiceException()
25300 
          self.ex.read(iprot)
25301 
        else:
25302 
          iprot.skip(ftype)
25303 
      else:
25304 
        iprot.skip(ftype)
25305 
      iprot.readFieldEnd()
25306 
    iprot.readStructEnd()
25307 
 
25308 
  def write(self, oprot):
25309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25311 
      return
25312 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25313 
    if self.success is not None:
25314 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25315 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25316 
      for iter613 in self.success:
25317 
        iter613.write(oprot)
5208 varun.gupt 25318 
      oprot.writeListEnd()
25319 
      oprot.writeFieldEnd()
25320 
    if self.ex is not None:
25321 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25322 
      self.ex.write(oprot)
25323 
      oprot.writeFieldEnd()
25324 
    oprot.writeFieldStop()
25325 
    oprot.writeStructEnd()
25326 
 
25327 
  def validate(self):
25328 
    return
25329 
 
25330 
 
25331 
  def __repr__(self):
25332 
    L = ['%s=%r' % (key, value)
25333 
      for key, value in self.__dict__.iteritems()]
25334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25335 
 
25336 
  def __eq__(self, other):
25337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25338 
 
25339 
  def __ne__(self, other):
25340 
    return not (self == other)
5447 anupam.sin 25341 
 
25342 
class getAllVerificationAgents_args:
25343 
  """
25344 
  Attributes:
25345 
   - minOrderId
25346 
   - maxOrderId
25347 
  """
25348 
 
25349 
  thrift_spec = (
25350 
    None, # 0
25351 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25352 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25353 
  )
25354 
 
25355 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25356 
    self.minOrderId = minOrderId
25357 
    self.maxOrderId = maxOrderId
25358 
 
25359 
  def read(self, iprot):
25360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25362 
      return
25363 
    iprot.readStructBegin()
25364 
    while True:
25365 
      (fname, ftype, fid) = iprot.readFieldBegin()
25366 
      if ftype == TType.STOP:
25367 
        break
25368 
      if fid == 1:
25369 
        if ftype == TType.I64:
25370 
          self.minOrderId = iprot.readI64();
25371 
        else:
25372 
          iprot.skip(ftype)
25373 
      elif fid == 2:
25374 
        if ftype == TType.I64:
25375 
          self.maxOrderId = iprot.readI64();
25376 
        else:
25377 
          iprot.skip(ftype)
25378 
      else:
25379 
        iprot.skip(ftype)
25380 
      iprot.readFieldEnd()
25381 
    iprot.readStructEnd()
25382 
 
25383 
  def write(self, oprot):
25384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25386 
      return
25387 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25388 
    if self.minOrderId is not None:
25389 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25390 
      oprot.writeI64(self.minOrderId)
25391 
      oprot.writeFieldEnd()
25392 
    if self.maxOrderId is not None:
25393 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25394 
      oprot.writeI64(self.maxOrderId)
25395 
      oprot.writeFieldEnd()
25396 
    oprot.writeFieldStop()
25397 
    oprot.writeStructEnd()
25398 
 
25399 
  def validate(self):
25400 
    return
25401 
 
25402 
 
25403 
  def __repr__(self):
25404 
    L = ['%s=%r' % (key, value)
25405 
      for key, value in self.__dict__.iteritems()]
25406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25407 
 
25408 
  def __eq__(self, other):
25409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25410 
 
25411 
  def __ne__(self, other):
25412 
    return not (self == other)
25413 
 
25414 
class getAllVerificationAgents_result:
25415 
  """
25416 
  Attributes:
25417 
   - success
25418 
  """
25419 
 
25420 
  thrift_spec = (
25421 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25422 
  )
25423 
 
25424 
  def __init__(self, success=None,):
25425 
    self.success = success
25426 
 
25427 
  def read(self, iprot):
25428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25430 
      return
25431 
    iprot.readStructBegin()
25432 
    while True:
25433 
      (fname, ftype, fid) = iprot.readFieldBegin()
25434 
      if ftype == TType.STOP:
25435 
        break
25436 
      if fid == 0:
25437 
        if ftype == TType.LIST:
25438 
          self.success = []
6188 rajveer 25439 
          (_etype617, _size614) = iprot.readListBegin()
25440 
          for _i618 in xrange(_size614):
25441 
            _elem619 = CODVerificationAgent()
25442 
            _elem619.read(iprot)
25443 
            self.success.append(_elem619)
5447 anupam.sin 25444 
          iprot.readListEnd()
25445 
        else:
25446 
          iprot.skip(ftype)
25447 
      else:
25448 
        iprot.skip(ftype)
25449 
      iprot.readFieldEnd()
25450 
    iprot.readStructEnd()
25451 
 
25452 
  def write(self, oprot):
25453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25455 
      return
25456 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25457 
    if self.success is not None:
25458 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25459 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25460 
      for iter620 in self.success:
25461 
        iter620.write(oprot)
5447 anupam.sin 25462 
      oprot.writeListEnd()
25463 
      oprot.writeFieldEnd()
25464 
    oprot.writeFieldStop()
25465 
    oprot.writeStructEnd()
25466 
 
25467 
  def validate(self):
25468 
    return
25469 
 
25470 
 
25471 
  def __repr__(self):
25472 
    L = ['%s=%r' % (key, value)
25473 
      for key, value in self.__dict__.iteritems()]
25474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25475 
 
25476 
  def __eq__(self, other):
25477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25478 
 
25479 
  def __ne__(self, other):
25480 
    return not (self == other)
5527 anupam.sin 25481 
 
25482 
class getAllAttributesForOrderId_args:
25483 
  """
25484 
  Attributes:
25485 
   - orderId
25486 
  """
25487 
 
25488 
  thrift_spec = (
25489 
    None, # 0
25490 
    (1, TType.I64, 'orderId', None, None, ), # 1
25491 
  )
25492 
 
25493 
  def __init__(self, orderId=None,):
25494 
    self.orderId = orderId
25495 
 
25496 
  def read(self, iprot):
25497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25499 
      return
25500 
    iprot.readStructBegin()
25501 
    while True:
25502 
      (fname, ftype, fid) = iprot.readFieldBegin()
25503 
      if ftype == TType.STOP:
25504 
        break
25505 
      if fid == 1:
25506 
        if ftype == TType.I64:
25507 
          self.orderId = iprot.readI64();
25508 
        else:
25509 
          iprot.skip(ftype)
25510 
      else:
25511 
        iprot.skip(ftype)
25512 
      iprot.readFieldEnd()
25513 
    iprot.readStructEnd()
25514 
 
25515 
  def write(self, oprot):
25516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25518 
      return
25519 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25520 
    if self.orderId is not None:
25521 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25522 
      oprot.writeI64(self.orderId)
25523 
      oprot.writeFieldEnd()
25524 
    oprot.writeFieldStop()
25525 
    oprot.writeStructEnd()
25526 
 
25527 
  def validate(self):
25528 
    return
25529 
 
25530 
 
25531 
  def __repr__(self):
25532 
    L = ['%s=%r' % (key, value)
25533 
      for key, value in self.__dict__.iteritems()]
25534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25535 
 
25536 
  def __eq__(self, other):
25537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25538 
 
25539 
  def __ne__(self, other):
25540 
    return not (self == other)
25541 
 
25542 
class getAllAttributesForOrderId_result:
25543 
  """
25544 
  Attributes:
25545 
   - success
25546 
  """
25547 
 
25548 
  thrift_spec = (
25549 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25550 
  )
25551 
 
25552 
  def __init__(self, success=None,):
25553 
    self.success = success
25554 
 
25555 
  def read(self, iprot):
25556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25558 
      return
25559 
    iprot.readStructBegin()
25560 
    while True:
25561 
      (fname, ftype, fid) = iprot.readFieldBegin()
25562 
      if ftype == TType.STOP:
25563 
        break
25564 
      if fid == 0:
25565 
        if ftype == TType.LIST:
25566 
          self.success = []
6188 rajveer 25567 
          (_etype624, _size621) = iprot.readListBegin()
25568 
          for _i625 in xrange(_size621):
25569 
            _elem626 = Attribute()
25570 
            _elem626.read(iprot)
25571 
            self.success.append(_elem626)
5527 anupam.sin 25572 
          iprot.readListEnd()
25573 
        else:
25574 
          iprot.skip(ftype)
25575 
      else:
25576 
        iprot.skip(ftype)
25577 
      iprot.readFieldEnd()
25578 
    iprot.readStructEnd()
25579 
 
25580 
  def write(self, oprot):
25581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25583 
      return
25584 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25585 
    if self.success is not None:
25586 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25587 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25588 
      for iter627 in self.success:
25589 
        iter627.write(oprot)
5527 anupam.sin 25590 
      oprot.writeListEnd()
25591 
      oprot.writeFieldEnd()
25592 
    oprot.writeFieldStop()
25593 
    oprot.writeStructEnd()
25594 
 
25595 
  def validate(self):
25596 
    return
25597 
 
25598 
 
25599 
  def __repr__(self):
25600 
    L = ['%s=%r' % (key, value)
25601 
      for key, value in self.__dict__.iteritems()]
25602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25603 
 
25604 
  def __eq__(self, other):
25605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25606 
 
25607 
  def __ne__(self, other):
25608 
    return not (self == other)
25609 
 
5676 rajveer 25610 
class setOrderAttributes_args:
25611 
  """
25612 
  Attributes:
25613 
   - orderId
25614 
   - attributes
25615 
  """
25616 
 
25617 
  thrift_spec = None
25618 
  def __init__(self, orderId=None, attributes=None,):
25619 
    self.orderId = orderId
25620 
    self.attributes = attributes
25621 
 
25622 
  def read(self, iprot):
25623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25625 
      return
25626 
    iprot.readStructBegin()
25627 
    while True:
25628 
      (fname, ftype, fid) = iprot.readFieldBegin()
25629 
      if ftype == TType.STOP:
25630 
        break
25631 
      if fid == 1:
25632 
        if ftype == TType.I64:
25633 
          self.orderId = iprot.readI64();
25634 
        else:
25635 
          iprot.skip(ftype)
25636 
      elif fid == -1:
25637 
        if ftype == TType.LIST:
25638 
          self.attributes = []
6188 rajveer 25639 
          (_etype631, _size628) = iprot.readListBegin()
25640 
          for _i632 in xrange(_size628):
25641 
            _elem633 = Attribute()
25642 
            _elem633.read(iprot)
25643 
            self.attributes.append(_elem633)
5676 rajveer 25644 
          iprot.readListEnd()
25645 
        else:
25646 
          iprot.skip(ftype)
25647 
      else:
25648 
        iprot.skip(ftype)
25649 
      iprot.readFieldEnd()
25650 
    iprot.readStructEnd()
25651 
 
25652 
  def write(self, oprot):
25653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25655 
      return
25656 
    oprot.writeStructBegin('setOrderAttributes_args')
25657 
    if self.attributes is not None:
25658 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25659 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25660 
      for iter634 in self.attributes:
25661 
        iter634.write(oprot)
5676 rajveer 25662 
      oprot.writeListEnd()
25663 
      oprot.writeFieldEnd()
25664 
    if self.orderId is not None:
25665 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25666 
      oprot.writeI64(self.orderId)
25667 
      oprot.writeFieldEnd()
25668 
    oprot.writeFieldStop()
25669 
    oprot.writeStructEnd()
25670 
 
25671 
  def validate(self):
25672 
    return
25673 
 
25674 
 
25675 
  def __repr__(self):
25676 
    L = ['%s=%r' % (key, value)
25677 
      for key, value in self.__dict__.iteritems()]
25678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25679 
 
25680 
  def __eq__(self, other):
25681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25682 
 
25683 
  def __ne__(self, other):
25684 
    return not (self == other)
25685 
 
25686 
class setOrderAttributes_result:
25687 
 
25688 
  thrift_spec = (
25689 
  )
25690 
 
25691 
  def read(self, iprot):
25692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25694 
      return
25695 
    iprot.readStructBegin()
25696 
    while True:
25697 
      (fname, ftype, fid) = iprot.readFieldBegin()
25698 
      if ftype == TType.STOP:
25699 
        break
25700 
      else:
25701 
        iprot.skip(ftype)
25702 
      iprot.readFieldEnd()
25703 
    iprot.readStructEnd()
25704 
 
25705 
  def write(self, oprot):
25706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25708 
      return
25709 
    oprot.writeStructBegin('setOrderAttributes_result')
25710 
    oprot.writeFieldStop()
25711 
    oprot.writeStructEnd()
25712 
 
25713 
  def validate(self):
25714 
    return
25715 
 
25716 
 
25717 
  def __repr__(self):
25718 
    L = ['%s=%r' % (key, value)
25719 
      for key, value in self.__dict__.iteritems()]
25720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25721 
 
25722 
  def __eq__(self, other):
25723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25724 
 
25725 
  def __ne__(self, other):
25726 
    return not (self == other)
25727 
 
5527 anupam.sin 25728 
class setOrderAttributeForTransaction_args:
25729 
  """
25730 
  Attributes:
25731 
   - transactionId
25732 
   - attribute
25733 
  """
25734 
 
25735 
  thrift_spec = None
25736 
  def __init__(self, transactionId=None, attribute=None,):
25737 
    self.transactionId = transactionId
25738 
    self.attribute = attribute
25739 
 
25740 
  def read(self, iprot):
25741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25743 
      return
25744 
    iprot.readStructBegin()
25745 
    while True:
25746 
      (fname, ftype, fid) = iprot.readFieldBegin()
25747 
      if ftype == TType.STOP:
25748 
        break
25749 
      if fid == 1:
25750 
        if ftype == TType.I64:
25751 
          self.transactionId = iprot.readI64();
25752 
        else:
25753 
          iprot.skip(ftype)
25754 
      elif fid == -1:
25755 
        if ftype == TType.STRUCT:
25756 
          self.attribute = Attribute()
25757 
          self.attribute.read(iprot)
25758 
        else:
25759 
          iprot.skip(ftype)
25760 
      else:
25761 
        iprot.skip(ftype)
25762 
      iprot.readFieldEnd()
25763 
    iprot.readStructEnd()
25764 
 
25765 
  def write(self, oprot):
25766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25768 
      return
25769 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25770 
    if self.attribute is not None:
25771 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25772 
      self.attribute.write(oprot)
25773 
      oprot.writeFieldEnd()
25774 
    if self.transactionId is not None:
25775 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25776 
      oprot.writeI64(self.transactionId)
25777 
      oprot.writeFieldEnd()
25778 
    oprot.writeFieldStop()
25779 
    oprot.writeStructEnd()
25780 
 
25781 
  def validate(self):
25782 
    return
25783 
 
25784 
 
25785 
  def __repr__(self):
25786 
    L = ['%s=%r' % (key, value)
25787 
      for key, value in self.__dict__.iteritems()]
25788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25789 
 
25790 
  def __eq__(self, other):
25791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25792 
 
25793 
  def __ne__(self, other):
25794 
    return not (self == other)
25795 
 
25796 
class setOrderAttributeForTransaction_result:
25797 
 
25798 
  thrift_spec = (
25799 
  )
25800 
 
25801 
  def read(self, iprot):
25802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25804 
      return
25805 
    iprot.readStructBegin()
25806 
    while True:
25807 
      (fname, ftype, fid) = iprot.readFieldBegin()
25808 
      if ftype == TType.STOP:
25809 
        break
25810 
      else:
25811 
        iprot.skip(ftype)
25812 
      iprot.readFieldEnd()
25813 
    iprot.readStructEnd()
25814 
 
25815 
  def write(self, oprot):
25816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25818 
      return
25819 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25820 
    oprot.writeFieldStop()
25821 
    oprot.writeStructEnd()
25822 
 
25823 
  def validate(self):
25824 
    return
25825 
 
25826 
 
25827 
  def __repr__(self):
25828 
    L = ['%s=%r' % (key, value)
25829 
      for key, value in self.__dict__.iteritems()]
25830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25831 
 
25832 
  def __eq__(self, other):
25833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25834 
 
25835 
  def __ne__(self, other):
25836 
    return not (self == other)
5553 rajveer 25837 
 
25838 
class getReceivePendingOrders_args:
25839 
  """
25840 
  Attributes:
25841 
   - storeId
25842 
  """
25843 
 
25844 
  thrift_spec = (
25845 
    None, # 0
25846 
    (1, TType.I64, 'storeId', None, None, ), # 1
25847 
  )
25848 
 
25849 
  def __init__(self, storeId=None,):
25850 
    self.storeId = storeId
25851 
 
25852 
  def read(self, iprot):
25853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25855 
      return
25856 
    iprot.readStructBegin()
25857 
    while True:
25858 
      (fname, ftype, fid) = iprot.readFieldBegin()
25859 
      if ftype == TType.STOP:
25860 
        break
25861 
      if fid == 1:
25862 
        if ftype == TType.I64:
25863 
          self.storeId = iprot.readI64();
25864 
        else:
25865 
          iprot.skip(ftype)
25866 
      else:
25867 
        iprot.skip(ftype)
25868 
      iprot.readFieldEnd()
25869 
    iprot.readStructEnd()
25870 
 
25871 
  def write(self, oprot):
25872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25874 
      return
25875 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25876 
    if self.storeId is not None:
25877 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25878 
      oprot.writeI64(self.storeId)
25879 
      oprot.writeFieldEnd()
25880 
    oprot.writeFieldStop()
25881 
    oprot.writeStructEnd()
25882 
 
25883 
  def validate(self):
25884 
    return
25885 
 
25886 
 
25887 
  def __repr__(self):
25888 
    L = ['%s=%r' % (key, value)
25889 
      for key, value in self.__dict__.iteritems()]
25890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25891 
 
25892 
  def __eq__(self, other):
25893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25894 
 
25895 
  def __ne__(self, other):
25896 
    return not (self == other)
25897 
 
25898 
class getReceivePendingOrders_result:
25899 
  """
25900 
  Attributes:
25901 
   - success
25902 
  """
25903 
 
25904 
  thrift_spec = (
25905 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25906 
  )
25907 
 
25908 
  def __init__(self, success=None,):
25909 
    self.success = success
25910 
 
25911 
  def read(self, iprot):
25912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25914 
      return
25915 
    iprot.readStructBegin()
25916 
    while True:
25917 
      (fname, ftype, fid) = iprot.readFieldBegin()
25918 
      if ftype == TType.STOP:
25919 
        break
25920 
      if fid == 0:
25921 
        if ftype == TType.LIST:
25922 
          self.success = []
6188 rajveer 25923 
          (_etype638, _size635) = iprot.readListBegin()
25924 
          for _i639 in xrange(_size635):
25925 
            _elem640 = Order()
25926 
            _elem640.read(iprot)
25927 
            self.success.append(_elem640)
5553 rajveer 25928 
          iprot.readListEnd()
25929 
        else:
25930 
          iprot.skip(ftype)
25931 
      else:
25932 
        iprot.skip(ftype)
25933 
      iprot.readFieldEnd()
25934 
    iprot.readStructEnd()
25935 
 
25936 
  def write(self, oprot):
25937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25939 
      return
25940 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25941 
    if self.success is not None:
25942 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25943 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25944 
      for iter641 in self.success:
25945 
        iter641.write(oprot)
5553 rajveer 25946 
      oprot.writeListEnd()
25947 
      oprot.writeFieldEnd()
25948 
    oprot.writeFieldStop()
25949 
    oprot.writeStructEnd()
25950 
 
25951 
  def validate(self):
25952 
    return
25953 
 
25954 
 
25955 
  def __repr__(self):
25956 
    L = ['%s=%r' % (key, value)
25957 
      for key, value in self.__dict__.iteritems()]
25958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25959 
 
25960 
  def __eq__(self, other):
25961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25962 
 
25963 
  def __ne__(self, other):
25964 
    return not (self == other)
25965 
 
25966 
class getReceivedAtStoreOrders_args:
25967 
  """
25968 
  Attributes:
25969 
   - storeId
25970 
  """
25971 
 
25972 
  thrift_spec = (
25973 
    None, # 0
25974 
    (1, TType.I64, 'storeId', None, None, ), # 1
25975 
  )
25976 
 
25977 
  def __init__(self, storeId=None,):
25978 
    self.storeId = storeId
25979 
 
25980 
  def read(self, iprot):
25981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25983 
      return
25984 
    iprot.readStructBegin()
25985 
    while True:
25986 
      (fname, ftype, fid) = iprot.readFieldBegin()
25987 
      if ftype == TType.STOP:
25988 
        break
25989 
      if fid == 1:
25990 
        if ftype == TType.I64:
25991 
          self.storeId = iprot.readI64();
25992 
        else:
25993 
          iprot.skip(ftype)
25994 
      else:
25995 
        iprot.skip(ftype)
25996 
      iprot.readFieldEnd()
25997 
    iprot.readStructEnd()
25998 
 
25999 
  def write(self, oprot):
26000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26002 
      return
26003 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26004 
    if self.storeId is not None:
26005 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26006 
      oprot.writeI64(self.storeId)
26007 
      oprot.writeFieldEnd()
26008 
    oprot.writeFieldStop()
26009 
    oprot.writeStructEnd()
26010 
 
26011 
  def validate(self):
26012 
    return
26013 
 
26014 
 
26015 
  def __repr__(self):
26016 
    L = ['%s=%r' % (key, value)
26017 
      for key, value in self.__dict__.iteritems()]
26018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26019 
 
26020 
  def __eq__(self, other):
26021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26022 
 
26023 
  def __ne__(self, other):
26024 
    return not (self == other)
26025 
 
26026 
class getReceivedAtStoreOrders_result:
26027 
  """
26028 
  Attributes:
26029 
   - success
26030 
  """
26031 
 
26032 
  thrift_spec = (
26033 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26034 
  )
26035 
 
26036 
  def __init__(self, success=None,):
26037 
    self.success = success
26038 
 
26039 
  def read(self, iprot):
26040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26042 
      return
26043 
    iprot.readStructBegin()
26044 
    while True:
26045 
      (fname, ftype, fid) = iprot.readFieldBegin()
26046 
      if ftype == TType.STOP:
26047 
        break
26048 
      if fid == 0:
26049 
        if ftype == TType.LIST:
26050 
          self.success = []
6188 rajveer 26051 
          (_etype645, _size642) = iprot.readListBegin()
26052 
          for _i646 in xrange(_size642):
26053 
            _elem647 = Order()
26054 
            _elem647.read(iprot)
26055 
            self.success.append(_elem647)
5553 rajveer 26056 
          iprot.readListEnd()
26057 
        else:
26058 
          iprot.skip(ftype)
26059 
      else:
26060 
        iprot.skip(ftype)
26061 
      iprot.readFieldEnd()
26062 
    iprot.readStructEnd()
26063 
 
26064 
  def write(self, oprot):
26065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26067 
      return
26068 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26069 
    if self.success is not None:
26070 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26071 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26072 
      for iter648 in self.success:
26073 
        iter648.write(oprot)
5553 rajveer 26074 
      oprot.writeListEnd()
26075 
      oprot.writeFieldEnd()
26076 
    oprot.writeFieldStop()
26077 
    oprot.writeStructEnd()
26078 
 
26079 
  def validate(self):
26080 
    return
26081 
 
26082 
 
26083 
  def __repr__(self):
26084 
    L = ['%s=%r' % (key, value)
26085 
      for key, value in self.__dict__.iteritems()]
26086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26087 
 
26088 
  def __eq__(self, other):
26089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26090 
 
26091 
  def __ne__(self, other):
26092 
    return not (self == other)
5593 mandeep.dh 26093 
 
5713 rajveer 26094 
class getOrdersCollectionAtStore_args:
26095 
  """
26096 
  Attributes:
26097 
   - storeId
26098 
   - fromDate
26099 
   - toDate
26100 
   - onlyCod
26101 
  """
26102 
 
26103 
  thrift_spec = (
26104 
    None, # 0
26105 
    (1, TType.I64, 'storeId', None, None, ), # 1
26106 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26107 
    (3, TType.I64, 'toDate', None, None, ), # 3
26108 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26109 
  )
26110 
 
26111 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26112 
    self.storeId = storeId
26113 
    self.fromDate = fromDate
26114 
    self.toDate = toDate
26115 
    self.onlyCod = onlyCod
26116 
 
26117 
  def read(self, iprot):
26118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26120 
      return
26121 
    iprot.readStructBegin()
26122 
    while True:
26123 
      (fname, ftype, fid) = iprot.readFieldBegin()
26124 
      if ftype == TType.STOP:
26125 
        break
26126 
      if fid == 1:
26127 
        if ftype == TType.I64:
26128 
          self.storeId = iprot.readI64();
26129 
        else:
26130 
          iprot.skip(ftype)
26131 
      elif fid == 2:
26132 
        if ftype == TType.I64:
26133 
          self.fromDate = iprot.readI64();
26134 
        else:
26135 
          iprot.skip(ftype)
26136 
      elif fid == 3:
26137 
        if ftype == TType.I64:
26138 
          self.toDate = iprot.readI64();
26139 
        else:
26140 
          iprot.skip(ftype)
26141 
      elif fid == 4:
26142 
        if ftype == TType.BOOL:
26143 
          self.onlyCod = iprot.readBool();
26144 
        else:
26145 
          iprot.skip(ftype)
26146 
      else:
26147 
        iprot.skip(ftype)
26148 
      iprot.readFieldEnd()
26149 
    iprot.readStructEnd()
26150 
 
26151 
  def write(self, oprot):
26152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26154 
      return
26155 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26156 
    if self.storeId is not None:
26157 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26158 
      oprot.writeI64(self.storeId)
26159 
      oprot.writeFieldEnd()
26160 
    if self.fromDate is not None:
26161 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26162 
      oprot.writeI64(self.fromDate)
26163 
      oprot.writeFieldEnd()
26164 
    if self.toDate is not None:
26165 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26166 
      oprot.writeI64(self.toDate)
26167 
      oprot.writeFieldEnd()
26168 
    if self.onlyCod is not None:
26169 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26170 
      oprot.writeBool(self.onlyCod)
26171 
      oprot.writeFieldEnd()
26172 
    oprot.writeFieldStop()
26173 
    oprot.writeStructEnd()
26174 
 
26175 
  def validate(self):
26176 
    return
26177 
 
26178 
 
26179 
  def __repr__(self):
26180 
    L = ['%s=%r' % (key, value)
26181 
      for key, value in self.__dict__.iteritems()]
26182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26183 
 
26184 
  def __eq__(self, other):
26185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26186 
 
26187 
  def __ne__(self, other):
26188 
    return not (self == other)
26189 
 
26190 
class getOrdersCollectionAtStore_result:
26191 
  """
26192 
  Attributes:
26193 
   - success
26194 
  """
26195 
 
26196 
  thrift_spec = (
26197 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26198 
  )
26199 
 
26200 
  def __init__(self, success=None,):
26201 
    self.success = success
26202 
 
26203 
  def read(self, iprot):
26204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26206 
      return
26207 
    iprot.readStructBegin()
26208 
    while True:
26209 
      (fname, ftype, fid) = iprot.readFieldBegin()
26210 
      if ftype == TType.STOP:
26211 
        break
26212 
      if fid == 0:
26213 
        if ftype == TType.LIST:
26214 
          self.success = []
6188 rajveer 26215 
          (_etype652, _size649) = iprot.readListBegin()
26216 
          for _i653 in xrange(_size649):
26217 
            _elem654 = Order()
26218 
            _elem654.read(iprot)
26219 
            self.success.append(_elem654)
5713 rajveer 26220 
          iprot.readListEnd()
26221 
        else:
26222 
          iprot.skip(ftype)
26223 
      else:
26224 
        iprot.skip(ftype)
26225 
      iprot.readFieldEnd()
26226 
    iprot.readStructEnd()
26227 
 
26228 
  def write(self, oprot):
26229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26231 
      return
26232 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26233 
    if self.success is not None:
26234 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26235 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26236 
      for iter655 in self.success:
26237 
        iter655.write(oprot)
5713 rajveer 26238 
      oprot.writeListEnd()
26239 
      oprot.writeFieldEnd()
26240 
    oprot.writeFieldStop()
26241 
    oprot.writeStructEnd()
26242 
 
26243 
  def validate(self):
26244 
    return
26245 
 
26246 
 
26247 
  def __repr__(self):
26248 
    L = ['%s=%r' % (key, value)
26249 
      for key, value in self.__dict__.iteritems()]
26250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26251 
 
26252 
  def __eq__(self, other):
26253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26254 
 
26255 
  def __ne__(self, other):
26256 
    return not (self == other)
26257 
 
5833 rajveer 26258 
class getOrderAttributeValue_args:
26259 
  """
26260 
  Attributes:
26261 
   - orderId
26262 
   - attributeName
26263 
  """
26264 
 
26265 
  thrift_spec = None
26266 
  def __init__(self, orderId=None, attributeName=None,):
26267 
    self.orderId = orderId
26268 
    self.attributeName = attributeName
26269 
 
26270 
  def read(self, iprot):
26271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26273 
      return
26274 
    iprot.readStructBegin()
26275 
    while True:
26276 
      (fname, ftype, fid) = iprot.readFieldBegin()
26277 
      if ftype == TType.STOP:
26278 
        break
26279 
      if fid == 1:
26280 
        if ftype == TType.I64:
26281 
          self.orderId = iprot.readI64();
26282 
        else:
26283 
          iprot.skip(ftype)
26284 
      elif fid == -1:
26285 
        if ftype == TType.STRING:
26286 
          self.attributeName = iprot.readString();
26287 
        else:
26288 
          iprot.skip(ftype)
26289 
      else:
26290 
        iprot.skip(ftype)
26291 
      iprot.readFieldEnd()
26292 
    iprot.readStructEnd()
26293 
 
26294 
  def write(self, oprot):
26295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26297 
      return
26298 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26299 
    if self.attributeName is not None:
26300 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26301 
      oprot.writeString(self.attributeName)
26302 
      oprot.writeFieldEnd()
26303 
    if self.orderId is not None:
26304 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26305 
      oprot.writeI64(self.orderId)
26306 
      oprot.writeFieldEnd()
26307 
    oprot.writeFieldStop()
26308 
    oprot.writeStructEnd()
26309 
 
26310 
  def validate(self):
26311 
    return
26312 
 
26313 
 
26314 
  def __repr__(self):
26315 
    L = ['%s=%r' % (key, value)
26316 
      for key, value in self.__dict__.iteritems()]
26317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26318 
 
26319 
  def __eq__(self, other):
26320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26321 
 
26322 
  def __ne__(self, other):
26323 
    return not (self == other)
26324 
 
26325 
class getOrderAttributeValue_result:
26326 
  """
26327 
  Attributes:
26328 
   - success
26329 
  """
26330 
 
26331 
  thrift_spec = (
26332 
    (0, TType.STRING, 'success', None, None, ), # 0
26333 
  )
26334 
 
26335 
  def __init__(self, success=None,):
26336 
    self.success = success
26337 
 
26338 
  def read(self, iprot):
26339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26341 
      return
26342 
    iprot.readStructBegin()
26343 
    while True:
26344 
      (fname, ftype, fid) = iprot.readFieldBegin()
26345 
      if ftype == TType.STOP:
26346 
        break
26347 
      if fid == 0:
26348 
        if ftype == TType.STRING:
26349 
          self.success = iprot.readString();
26350 
        else:
26351 
          iprot.skip(ftype)
26352 
      else:
26353 
        iprot.skip(ftype)
26354 
      iprot.readFieldEnd()
26355 
    iprot.readStructEnd()
26356 
 
26357 
  def write(self, oprot):
26358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26360 
      return
26361 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26362 
    if self.success is not None:
26363 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26364 
      oprot.writeString(self.success)
26365 
      oprot.writeFieldEnd()
26366 
    oprot.writeFieldStop()
26367 
    oprot.writeStructEnd()
26368 
 
26369 
  def validate(self):
26370 
    return
26371 
 
26372 
 
26373 
  def __repr__(self):
26374 
    L = ['%s=%r' % (key, value)
26375 
      for key, value in self.__dict__.iteritems()]
26376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26377 
 
26378 
  def __eq__(self, other):
26379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26380 
 
26381 
  def __ne__(self, other):
26382 
    return not (self == other)
26383 
 
6019 rajveer 26384 
class changeJacketNumber_args:
26385 
  """
26386 
  Attributes:
26387 
   - orderId
26388 
   - jacketNumber
26389 
  """
26390 
 
26391 
  thrift_spec = (
26392 
    None, # 0
26393 
    (1, TType.I64, 'orderId', None, None, ), # 1
26394 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26395 
  )
26396 
 
26397 
  def __init__(self, orderId=None, jacketNumber=None,):
26398 
    self.orderId = orderId
26399 
    self.jacketNumber = jacketNumber
26400 
 
26401 
  def read(self, iprot):
26402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26404 
      return
26405 
    iprot.readStructBegin()
26406 
    while True:
26407 
      (fname, ftype, fid) = iprot.readFieldBegin()
26408 
      if ftype == TType.STOP:
26409 
        break
26410 
      if fid == 1:
26411 
        if ftype == TType.I64:
26412 
          self.orderId = iprot.readI64();
26413 
        else:
26414 
          iprot.skip(ftype)
26415 
      elif fid == 2:
26416 
        if ftype == TType.I64:
26417 
          self.jacketNumber = iprot.readI64();
26418 
        else:
26419 
          iprot.skip(ftype)
26420 
      else:
26421 
        iprot.skip(ftype)
26422 
      iprot.readFieldEnd()
26423 
    iprot.readStructEnd()
26424 
 
26425 
  def write(self, oprot):
26426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26428 
      return
26429 
    oprot.writeStructBegin('changeJacketNumber_args')
26430 
    if self.orderId is not None:
26431 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26432 
      oprot.writeI64(self.orderId)
26433 
      oprot.writeFieldEnd()
26434 
    if self.jacketNumber is not None:
26435 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26436 
      oprot.writeI64(self.jacketNumber)
26437 
      oprot.writeFieldEnd()
26438 
    oprot.writeFieldStop()
26439 
    oprot.writeStructEnd()
26440 
 
26441 
  def validate(self):
26442 
    return
26443 
 
26444 
 
26445 
  def __repr__(self):
26446 
    L = ['%s=%r' % (key, value)
26447 
      for key, value in self.__dict__.iteritems()]
26448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26449 
 
26450 
  def __eq__(self, other):
26451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26452 
 
26453 
  def __ne__(self, other):
26454 
    return not (self == other)
26455 
 
26456 
class changeJacketNumber_result:
26457 
  """
26458 
  Attributes:
26459 
   - success
26460 
  """
26461 
 
26462 
  thrift_spec = (
26463 
    (0, TType.BOOL, 'success', None, None, ), # 0
26464 
  )
26465 
 
26466 
  def __init__(self, success=None,):
26467 
    self.success = success
26468 
 
26469 
  def read(self, iprot):
26470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26472 
      return
26473 
    iprot.readStructBegin()
26474 
    while True:
26475 
      (fname, ftype, fid) = iprot.readFieldBegin()
26476 
      if ftype == TType.STOP:
26477 
        break
26478 
      if fid == 0:
26479 
        if ftype == TType.BOOL:
26480 
          self.success = iprot.readBool();
26481 
        else:
26482 
          iprot.skip(ftype)
26483 
      else:
26484 
        iprot.skip(ftype)
26485 
      iprot.readFieldEnd()
26486 
    iprot.readStructEnd()
26487 
 
26488 
  def write(self, oprot):
26489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26491 
      return
26492 
    oprot.writeStructBegin('changeJacketNumber_result')
26493 
    if self.success is not None:
26494 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26495 
      oprot.writeBool(self.success)
26496 
      oprot.writeFieldEnd()
26497 
    oprot.writeFieldStop()
26498 
    oprot.writeStructEnd()
26499 
 
26500 
  def validate(self):
26501 
    return
26502 
 
26503 
 
26504 
  def __repr__(self):
26505 
    L = ['%s=%r' % (key, value)
26506 
      for key, value in self.__dict__.iteritems()]
26507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26508 
 
26509 
  def __eq__(self, other):
26510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26511 
 
26512 
  def __ne__(self, other):
26513 
    return not (self == other)
26514 
 
26515 
class markOrderAsRtoInTransit_args:
26516 
  """
26517 
  Attributes:
26518 
   - orderId
26519 
  """
26520 
 
26521 
  thrift_spec = (
26522 
    None, # 0
26523 
    (1, TType.I64, 'orderId', None, None, ), # 1
26524 
  )
26525 
 
26526 
  def __init__(self, orderId=None,):
26527 
    self.orderId = orderId
26528 
 
26529 
  def read(self, iprot):
26530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26532 
      return
26533 
    iprot.readStructBegin()
26534 
    while True:
26535 
      (fname, ftype, fid) = iprot.readFieldBegin()
26536 
      if ftype == TType.STOP:
26537 
        break
26538 
      if fid == 1:
26539 
        if ftype == TType.I64:
26540 
          self.orderId = iprot.readI64();
26541 
        else:
26542 
          iprot.skip(ftype)
26543 
      else:
26544 
        iprot.skip(ftype)
26545 
      iprot.readFieldEnd()
26546 
    iprot.readStructEnd()
26547 
 
26548 
  def write(self, oprot):
26549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26551 
      return
26552 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26553 
    if self.orderId is not None:
26554 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26555 
      oprot.writeI64(self.orderId)
26556 
      oprot.writeFieldEnd()
26557 
    oprot.writeFieldStop()
26558 
    oprot.writeStructEnd()
26559 
 
26560 
  def validate(self):
26561 
    return
26562 
 
26563 
 
26564 
  def __repr__(self):
26565 
    L = ['%s=%r' % (key, value)
26566 
      for key, value in self.__dict__.iteritems()]
26567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26568 
 
26569 
  def __eq__(self, other):
26570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26571 
 
26572 
  def __ne__(self, other):
26573 
    return not (self == other)
26574 
 
26575 
class markOrderAsRtoInTransit_result:
26576 
  """
26577 
  Attributes:
26578 
   - success
26579 
  """
26580 
 
26581 
  thrift_spec = (
26582 
    (0, TType.BOOL, 'success', None, None, ), # 0
26583 
  )
26584 
 
26585 
  def __init__(self, success=None,):
26586 
    self.success = success
26587 
 
26588 
  def read(self, iprot):
26589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26591 
      return
26592 
    iprot.readStructBegin()
26593 
    while True:
26594 
      (fname, ftype, fid) = iprot.readFieldBegin()
26595 
      if ftype == TType.STOP:
26596 
        break
26597 
      if fid == 0:
26598 
        if ftype == TType.BOOL:
26599 
          self.success = iprot.readBool();
26600 
        else:
26601 
          iprot.skip(ftype)
26602 
      else:
26603 
        iprot.skip(ftype)
26604 
      iprot.readFieldEnd()
26605 
    iprot.readStructEnd()
26606 
 
26607 
  def write(self, oprot):
26608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26610 
      return
26611 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26612 
    if self.success is not None:
26613 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26614 
      oprot.writeBool(self.success)
26615 
      oprot.writeFieldEnd()
26616 
    oprot.writeFieldStop()
26617 
    oprot.writeStructEnd()
26618 
 
26619 
  def validate(self):
26620 
    return
26621 
 
26622 
 
26623 
  def __repr__(self):
26624 
    L = ['%s=%r' % (key, value)
26625 
      for key, value in self.__dict__.iteritems()]
26626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26627 
 
26628 
  def __eq__(self, other):
26629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26630 
 
26631 
  def __ne__(self, other):
26632 
    return not (self == other)
26633 
 
5593 mandeep.dh 26634 
class acceptOrderForItem_args:
26635 
  """
26636 
  Attributes:
26637 
   - itemId
26638 
   - quantity
26639 
   - fulfilmentWarehouseId
26640 
   - billingWarehouseId
26641 
  """
26642 
 
26643 
  thrift_spec = (
26644 
    None, # 0
26645 
    (1, TType.I64, 'itemId', None, None, ), # 1
26646 
    (2, TType.I64, 'quantity', None, None, ), # 2
26647 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26648 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26649 
  )
26650 
 
26651 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26652 
    self.itemId = itemId
26653 
    self.quantity = quantity
26654 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26655 
    self.billingWarehouseId = billingWarehouseId
26656 
 
26657 
  def read(self, iprot):
26658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26660 
      return
26661 
    iprot.readStructBegin()
26662 
    while True:
26663 
      (fname, ftype, fid) = iprot.readFieldBegin()
26664 
      if ftype == TType.STOP:
26665 
        break
26666 
      if fid == 1:
26667 
        if ftype == TType.I64:
26668 
          self.itemId = iprot.readI64();
26669 
        else:
26670 
          iprot.skip(ftype)
26671 
      elif fid == 2:
26672 
        if ftype == TType.I64:
26673 
          self.quantity = iprot.readI64();
26674 
        else:
26675 
          iprot.skip(ftype)
26676 
      elif fid == 3:
26677 
        if ftype == TType.I64:
26678 
          self.fulfilmentWarehouseId = iprot.readI64();
26679 
        else:
26680 
          iprot.skip(ftype)
26681 
      elif fid == 4:
26682 
        if ftype == TType.I64:
26683 
          self.billingWarehouseId = iprot.readI64();
26684 
        else:
26685 
          iprot.skip(ftype)
26686 
      else:
26687 
        iprot.skip(ftype)
26688 
      iprot.readFieldEnd()
26689 
    iprot.readStructEnd()
26690 
 
26691 
  def write(self, oprot):
26692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26694 
      return
26695 
    oprot.writeStructBegin('acceptOrderForItem_args')
26696 
    if self.itemId is not None:
26697 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26698 
      oprot.writeI64(self.itemId)
26699 
      oprot.writeFieldEnd()
26700 
    if self.quantity is not None:
26701 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26702 
      oprot.writeI64(self.quantity)
26703 
      oprot.writeFieldEnd()
26704 
    if self.fulfilmentWarehouseId is not None:
26705 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26706 
      oprot.writeI64(self.fulfilmentWarehouseId)
26707 
      oprot.writeFieldEnd()
26708 
    if self.billingWarehouseId is not None:
26709 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26710 
      oprot.writeI64(self.billingWarehouseId)
26711 
      oprot.writeFieldEnd()
26712 
    oprot.writeFieldStop()
26713 
    oprot.writeStructEnd()
26714 
 
26715 
  def validate(self):
26716 
    return
26717 
 
26718 
 
26719 
  def __repr__(self):
26720 
    L = ['%s=%r' % (key, value)
26721 
      for key, value in self.__dict__.iteritems()]
26722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26723 
 
26724 
  def __eq__(self, other):
26725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26726 
 
26727 
  def __ne__(self, other):
26728 
    return not (self == other)
26729 
 
26730 
class acceptOrderForItem_result:
26731 
 
26732 
  thrift_spec = (
26733 
  )
26734 
 
26735 
  def read(self, iprot):
26736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26738 
      return
26739 
    iprot.readStructBegin()
26740 
    while True:
26741 
      (fname, ftype, fid) = iprot.readFieldBegin()
26742 
      if ftype == TType.STOP:
26743 
        break
26744 
      else:
26745 
        iprot.skip(ftype)
26746 
      iprot.readFieldEnd()
26747 
    iprot.readStructEnd()
26748 
 
26749 
  def write(self, oprot):
26750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26752 
      return
26753 
    oprot.writeStructBegin('acceptOrderForItem_result')
26754 
    oprot.writeFieldStop()
26755 
    oprot.writeStructEnd()
26756 
 
26757 
  def validate(self):
26758 
    return
26759 
 
26760 
 
26761 
  def __repr__(self):
26762 
    L = ['%s=%r' % (key, value)
26763 
      for key, value in self.__dict__.iteritems()]
26764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26765 
 
26766 
  def __eq__(self, other):
26767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26768 
 
26769 
  def __ne__(self, other):
26770 
    return not (self == other)
6000 mandeep.dh 26771 
 
26772 
class createRechargeOrder_args:
26773 
  """
26774 
  Attributes:
26775 
   - rechargeOrder
26776 
  """
26777 
 
26778 
  thrift_spec = (
26779 
    None, # 0
26780 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26781 
  )
26782 
 
26783 
  def __init__(self, rechargeOrder=None,):
26784 
    self.rechargeOrder = rechargeOrder
26785 
 
26786 
  def read(self, iprot):
26787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26789 
      return
26790 
    iprot.readStructBegin()
26791 
    while True:
26792 
      (fname, ftype, fid) = iprot.readFieldBegin()
26793 
      if ftype == TType.STOP:
26794 
        break
26795 
      if fid == 1:
26796 
        if ftype == TType.STRUCT:
26797 
          self.rechargeOrder = RechargeOrder()
26798 
          self.rechargeOrder.read(iprot)
26799 
        else:
26800 
          iprot.skip(ftype)
26801 
      else:
26802 
        iprot.skip(ftype)
26803 
      iprot.readFieldEnd()
26804 
    iprot.readStructEnd()
26805 
 
26806 
  def write(self, oprot):
26807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26809 
      return
26810 
    oprot.writeStructBegin('createRechargeOrder_args')
26811 
    if self.rechargeOrder is not None:
26812 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26813 
      self.rechargeOrder.write(oprot)
26814 
      oprot.writeFieldEnd()
26815 
    oprot.writeFieldStop()
26816 
    oprot.writeStructEnd()
26817 
 
26818 
  def validate(self):
26819 
    return
26820 
 
26821 
 
26822 
  def __repr__(self):
26823 
    L = ['%s=%r' % (key, value)
26824 
      for key, value in self.__dict__.iteritems()]
26825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26826 
 
26827 
  def __eq__(self, other):
26828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26829 
 
26830 
  def __ne__(self, other):
26831 
    return not (self == other)
26832 
 
26833 
class createRechargeOrder_result:
26834 
  """
26835 
  Attributes:
26836 
   - success
26837 
   - ex
26838 
  """
26839 
 
26840 
  thrift_spec = (
26841 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26843 
  )
26844 
 
26845 
  def __init__(self, success=None, ex=None,):
26846 
    self.success = success
26847 
    self.ex = ex
26848 
 
26849 
  def read(self, iprot):
26850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26852 
      return
26853 
    iprot.readStructBegin()
26854 
    while True:
26855 
      (fname, ftype, fid) = iprot.readFieldBegin()
26856 
      if ftype == TType.STOP:
26857 
        break
26858 
      if fid == 0:
26859 
        if ftype == TType.STRUCT:
26860 
          self.success = RechargeOrder()
26861 
          self.success.read(iprot)
26862 
        else:
26863 
          iprot.skip(ftype)
26864 
      elif fid == 1:
26865 
        if ftype == TType.STRUCT:
26866 
          self.ex = TransactionServiceException()
26867 
          self.ex.read(iprot)
26868 
        else:
26869 
          iprot.skip(ftype)
26870 
      else:
26871 
        iprot.skip(ftype)
26872 
      iprot.readFieldEnd()
26873 
    iprot.readStructEnd()
26874 
 
26875 
  def write(self, oprot):
26876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26878 
      return
26879 
    oprot.writeStructBegin('createRechargeOrder_result')
26880 
    if self.success is not None:
26881 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26882 
      self.success.write(oprot)
26883 
      oprot.writeFieldEnd()
26884 
    if self.ex is not None:
26885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26886 
      self.ex.write(oprot)
26887 
      oprot.writeFieldEnd()
26888 
    oprot.writeFieldStop()
26889 
    oprot.writeStructEnd()
26890 
 
26891 
  def validate(self):
26892 
    return
26893 
 
26894 
 
26895 
  def __repr__(self):
26896 
    L = ['%s=%r' % (key, value)
26897 
      for key, value in self.__dict__.iteritems()]
26898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26899 
 
26900 
  def __eq__(self, other):
26901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26902 
 
26903 
  def __ne__(self, other):
26904 
    return not (self == other)
26905 
 
6031 rajveer 26906 
class getRechargeOrder_args:
26907 
  """
26908 
  Attributes:
26909 
   - rechargeRrderId
26910 
  """
26911 
 
26912 
  thrift_spec = (
26913 
    None, # 0
26914 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26915 
  )
26916 
 
26917 
  def __init__(self, rechargeRrderId=None,):
26918 
    self.rechargeRrderId = rechargeRrderId
26919 
 
26920 
  def read(self, iprot):
26921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26923 
      return
26924 
    iprot.readStructBegin()
26925 
    while True:
26926 
      (fname, ftype, fid) = iprot.readFieldBegin()
26927 
      if ftype == TType.STOP:
26928 
        break
26929 
      if fid == 1:
26930 
        if ftype == TType.I64:
26931 
          self.rechargeRrderId = iprot.readI64();
26932 
        else:
26933 
          iprot.skip(ftype)
26934 
      else:
26935 
        iprot.skip(ftype)
26936 
      iprot.readFieldEnd()
26937 
    iprot.readStructEnd()
26938 
 
26939 
  def write(self, oprot):
26940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26942 
      return
26943 
    oprot.writeStructBegin('getRechargeOrder_args')
26944 
    if self.rechargeRrderId is not None:
26945 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26946 
      oprot.writeI64(self.rechargeRrderId)
26947 
      oprot.writeFieldEnd()
26948 
    oprot.writeFieldStop()
26949 
    oprot.writeStructEnd()
26950 
 
26951 
  def validate(self):
26952 
    return
26953 
 
26954 
 
26955 
  def __repr__(self):
26956 
    L = ['%s=%r' % (key, value)
26957 
      for key, value in self.__dict__.iteritems()]
26958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26959 
 
26960 
  def __eq__(self, other):
26961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26962 
 
26963 
  def __ne__(self, other):
26964 
    return not (self == other)
26965 
 
26966 
class getRechargeOrder_result:
26967 
  """
26968 
  Attributes:
26969 
   - success
26970 
   - ex
26971 
  """
26972 
 
26973 
  thrift_spec = (
26974 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26975 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26976 
  )
26977 
 
26978 
  def __init__(self, success=None, ex=None,):
26979 
    self.success = success
26980 
    self.ex = ex
26981 
 
26982 
  def read(self, iprot):
26983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26985 
      return
26986 
    iprot.readStructBegin()
26987 
    while True:
26988 
      (fname, ftype, fid) = iprot.readFieldBegin()
26989 
      if ftype == TType.STOP:
26990 
        break
26991 
      if fid == 0:
26992 
        if ftype == TType.STRUCT:
26993 
          self.success = RechargeOrder()
26994 
          self.success.read(iprot)
26995 
        else:
26996 
          iprot.skip(ftype)
26997 
      elif fid == 1:
26998 
        if ftype == TType.STRUCT:
26999 
          self.ex = TransactionServiceException()
27000 
          self.ex.read(iprot)
27001 
        else:
27002 
          iprot.skip(ftype)
27003 
      else:
27004 
        iprot.skip(ftype)
27005 
      iprot.readFieldEnd()
27006 
    iprot.readStructEnd()
27007 
 
27008 
  def write(self, oprot):
27009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27011 
      return
27012 
    oprot.writeStructBegin('getRechargeOrder_result')
27013 
    if self.success is not None:
27014 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27015 
      self.success.write(oprot)
27016 
      oprot.writeFieldEnd()
27017 
    if self.ex is not None:
27018 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27019 
      self.ex.write(oprot)
27020 
      oprot.writeFieldEnd()
27021 
    oprot.writeFieldStop()
27022 
    oprot.writeStructEnd()
27023 
 
27024 
  def validate(self):
27025 
    return
27026 
 
27027 
 
27028 
  def __repr__(self):
27029 
    L = ['%s=%r' % (key, value)
27030 
      for key, value in self.__dict__.iteritems()]
27031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27032 
 
27033 
  def __eq__(self, other):
27034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27035 
 
27036 
  def __ne__(self, other):
27037 
    return not (self == other)
27038 
 
27039 
class getRechargeOrders_args:
27040 
  """
27041 
  Attributes:
27042 
   - userId
27043 
  """
27044 
 
27045 
  thrift_spec = (
27046 
    None, # 0
27047 
    (1, TType.I64, 'userId', None, None, ), # 1
27048 
  )
27049 
 
27050 
  def __init__(self, userId=None,):
27051 
    self.userId = userId
27052 
 
27053 
  def read(self, iprot):
27054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27056 
      return
27057 
    iprot.readStructBegin()
27058 
    while True:
27059 
      (fname, ftype, fid) = iprot.readFieldBegin()
27060 
      if ftype == TType.STOP:
27061 
        break
27062 
      if fid == 1:
27063 
        if ftype == TType.I64:
27064 
          self.userId = iprot.readI64();
27065 
        else:
27066 
          iprot.skip(ftype)
27067 
      else:
27068 
        iprot.skip(ftype)
27069 
      iprot.readFieldEnd()
27070 
    iprot.readStructEnd()
27071 
 
27072 
  def write(self, oprot):
27073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27075 
      return
27076 
    oprot.writeStructBegin('getRechargeOrders_args')
27077 
    if self.userId is not None:
27078 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27079 
      oprot.writeI64(self.userId)
27080 
      oprot.writeFieldEnd()
27081 
    oprot.writeFieldStop()
27082 
    oprot.writeStructEnd()
27083 
 
27084 
  def validate(self):
27085 
    return
27086 
 
27087 
 
27088 
  def __repr__(self):
27089 
    L = ['%s=%r' % (key, value)
27090 
      for key, value in self.__dict__.iteritems()]
27091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27092 
 
27093 
  def __eq__(self, other):
27094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27095 
 
27096 
  def __ne__(self, other):
27097 
    return not (self == other)
27098 
 
27099 
class getRechargeOrders_result:
27100 
  """
27101 
  Attributes:
27102 
   - success
27103 
  """
27104 
 
27105 
  thrift_spec = (
27106 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27107 
  )
27108 
 
27109 
  def __init__(self, success=None,):
27110 
    self.success = success
27111 
 
27112 
  def read(self, iprot):
27113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27115 
      return
27116 
    iprot.readStructBegin()
27117 
    while True:
27118 
      (fname, ftype, fid) = iprot.readFieldBegin()
27119 
      if ftype == TType.STOP:
27120 
        break
27121 
      if fid == 0:
27122 
        if ftype == TType.LIST:
27123 
          self.success = []
6188 rajveer 27124 
          (_etype659, _size656) = iprot.readListBegin()
27125 
          for _i660 in xrange(_size656):
27126 
            _elem661 = RechargeOrder()
27127 
            _elem661.read(iprot)
27128 
            self.success.append(_elem661)
6031 rajveer 27129 
          iprot.readListEnd()
27130 
        else:
27131 
          iprot.skip(ftype)
27132 
      else:
27133 
        iprot.skip(ftype)
27134 
      iprot.readFieldEnd()
27135 
    iprot.readStructEnd()
27136 
 
27137 
  def write(self, oprot):
27138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27140 
      return
27141 
    oprot.writeStructBegin('getRechargeOrders_result')
27142 
    if self.success is not None:
27143 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27144 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27145 
      for iter662 in self.success:
27146 
        iter662.write(oprot)
6031 rajveer 27147 
      oprot.writeListEnd()
27148 
      oprot.writeFieldEnd()
27149 
    oprot.writeFieldStop()
27150 
    oprot.writeStructEnd()
27151 
 
27152 
  def validate(self):
27153 
    return
27154 
 
27155 
 
27156 
  def __repr__(self):
27157 
    L = ['%s=%r' % (key, value)
27158 
      for key, value in self.__dict__.iteritems()]
27159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27160 
 
27161 
  def __eq__(self, other):
27162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27163 
 
27164 
  def __ne__(self, other):
27165 
    return not (self == other)
27166 
 
6000 mandeep.dh 27167 
class updateRechargeOrderStatus_args:
27168 
  """
27169 
  Attributes:
27170 
   - rechargeOrderId
27171 
   - rechargeOrderStatus
27172 
  """
27173 
 
27174 
  thrift_spec = (
27175 
    None, # 0
27176 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27177 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27178 
  )
27179 
 
27180 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27181 
    self.rechargeOrderId = rechargeOrderId
27182 
    self.rechargeOrderStatus = rechargeOrderStatus
27183 
 
27184 
  def read(self, iprot):
27185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27187 
      return
27188 
    iprot.readStructBegin()
27189 
    while True:
27190 
      (fname, ftype, fid) = iprot.readFieldBegin()
27191 
      if ftype == TType.STOP:
27192 
        break
27193 
      if fid == 1:
27194 
        if ftype == TType.I64:
27195 
          self.rechargeOrderId = iprot.readI64();
27196 
        else:
27197 
          iprot.skip(ftype)
27198 
      elif fid == 2:
27199 
        if ftype == TType.I32:
27200 
          self.rechargeOrderStatus = iprot.readI32();
27201 
        else:
27202 
          iprot.skip(ftype)
27203 
      else:
27204 
        iprot.skip(ftype)
27205 
      iprot.readFieldEnd()
27206 
    iprot.readStructEnd()
27207 
 
27208 
  def write(self, oprot):
27209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27211 
      return
27212 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27213 
    if self.rechargeOrderId is not None:
27214 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27215 
      oprot.writeI64(self.rechargeOrderId)
27216 
      oprot.writeFieldEnd()
27217 
    if self.rechargeOrderStatus is not None:
27218 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27219 
      oprot.writeI32(self.rechargeOrderStatus)
27220 
      oprot.writeFieldEnd()
27221 
    oprot.writeFieldStop()
27222 
    oprot.writeStructEnd()
27223 
 
27224 
  def validate(self):
27225 
    return
27226 
 
27227 
 
27228 
  def __repr__(self):
27229 
    L = ['%s=%r' % (key, value)
27230 
      for key, value in self.__dict__.iteritems()]
27231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27232 
 
27233 
  def __eq__(self, other):
27234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27235 
 
27236 
  def __ne__(self, other):
27237 
    return not (self == other)
27238 
 
27239 
class updateRechargeOrderStatus_result:
27240 
  """
27241 
  Attributes:
6031 rajveer 27242 
   - success
6000 mandeep.dh 27243 
   - ex
27244 
  """
27245 
 
27246 
  thrift_spec = (
6031 rajveer 27247 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27248 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27249 
  )
27250 
 
6031 rajveer 27251 
  def __init__(self, success=None, ex=None,):
27252 
    self.success = success
6000 mandeep.dh 27253 
    self.ex = ex
27254 
 
27255 
  def read(self, iprot):
27256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27258 
      return
27259 
    iprot.readStructBegin()
27260 
    while True:
27261 
      (fname, ftype, fid) = iprot.readFieldBegin()
27262 
      if ftype == TType.STOP:
27263 
        break
6031 rajveer 27264 
      if fid == 0:
27265 
        if ftype == TType.BOOL:
27266 
          self.success = iprot.readBool();
27267 
        else:
27268 
          iprot.skip(ftype)
27269 
      elif fid == 1:
6000 mandeep.dh 27270 
        if ftype == TType.STRUCT:
27271 
          self.ex = TransactionServiceException()
27272 
          self.ex.read(iprot)
27273 
        else:
27274 
          iprot.skip(ftype)
27275 
      else:
27276 
        iprot.skip(ftype)
27277 
      iprot.readFieldEnd()
27278 
    iprot.readStructEnd()
27279 
 
27280 
  def write(self, oprot):
27281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27283 
      return
27284 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27285 
    if self.success is not None:
27286 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27287 
      oprot.writeBool(self.success)
27288 
      oprot.writeFieldEnd()
6000 mandeep.dh 27289 
    if self.ex is not None:
27290 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27291 
      self.ex.write(oprot)
27292 
      oprot.writeFieldEnd()
27293 
    oprot.writeFieldStop()
27294 
    oprot.writeStructEnd()
27295 
 
27296 
  def validate(self):
27297 
    return
27298 
 
27299 
 
27300 
  def __repr__(self):
27301 
    L = ['%s=%r' % (key, value)
27302 
      for key, value in self.__dict__.iteritems()]
27303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27304 
 
27305 
  def __eq__(self, other):
27306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27307 
 
27308 
  def __ne__(self, other):
27309 
    return not (self == other)
27310 
 
27311 
class activateRechargeTxn_args:
27312 
  """
27313 
  Attributes:
6031 rajveer 27314 
   - rechargeOrderId
6000 mandeep.dh 27315 
  """
27316 
 
27317 
  thrift_spec = (
27318 
    None, # 0
6031 rajveer 27319 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27320 
  )
27321 
 
6031 rajveer 27322 
  def __init__(self, rechargeOrderId=None,):
27323 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27324 
 
27325 
  def read(self, iprot):
27326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27328 
      return
27329 
    iprot.readStructBegin()
27330 
    while True:
27331 
      (fname, ftype, fid) = iprot.readFieldBegin()
27332 
      if ftype == TType.STOP:
27333 
        break
27334 
      if fid == 1:
6031 rajveer 27335 
        if ftype == TType.I64:
27336 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27337 
        else:
27338 
          iprot.skip(ftype)
27339 
      else:
27340 
        iprot.skip(ftype)
27341 
      iprot.readFieldEnd()
27342 
    iprot.readStructEnd()
27343 
 
27344 
  def write(self, oprot):
27345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27347 
      return
27348 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27349 
    if self.rechargeOrderId is not None:
27350 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27351 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27352 
      oprot.writeFieldEnd()
27353 
    oprot.writeFieldStop()
27354 
    oprot.writeStructEnd()
27355 
 
27356 
  def validate(self):
27357 
    return
27358 
 
27359 
 
27360 
  def __repr__(self):
27361 
    L = ['%s=%r' % (key, value)
27362 
      for key, value in self.__dict__.iteritems()]
27363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27364 
 
27365 
  def __eq__(self, other):
27366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27367 
 
27368 
  def __ne__(self, other):
27369 
    return not (self == other)
27370 
 
27371 
class activateRechargeTxn_result:
27372 
  """
27373 
  Attributes:
27374 
   - success
27375 
   - ex
27376 
  """
27377 
 
27378 
  thrift_spec = (
6031 rajveer 27379 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27380 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27381 
  )
27382 
 
27383 
  def __init__(self, success=None, ex=None,):
27384 
    self.success = success
27385 
    self.ex = ex
27386 
 
27387 
  def read(self, iprot):
27388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27390 
      return
27391 
    iprot.readStructBegin()
27392 
    while True:
27393 
      (fname, ftype, fid) = iprot.readFieldBegin()
27394 
      if ftype == TType.STOP:
27395 
        break
27396 
      if fid == 0:
6031 rajveer 27397 
        if ftype == TType.BOOL:
27398 
          self.success = iprot.readBool();
6000 mandeep.dh 27399 
        else:
27400 
          iprot.skip(ftype)
27401 
      elif fid == 1:
27402 
        if ftype == TType.STRUCT:
27403 
          self.ex = TransactionServiceException()
27404 
          self.ex.read(iprot)
27405 
        else:
27406 
          iprot.skip(ftype)
27407 
      else:
27408 
        iprot.skip(ftype)
27409 
      iprot.readFieldEnd()
27410 
    iprot.readStructEnd()
27411 
 
27412 
  def write(self, oprot):
27413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27415 
      return
27416 
    oprot.writeStructBegin('activateRechargeTxn_result')
27417 
    if self.success is not None:
6031 rajveer 27418 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27419 
      oprot.writeBool(self.success)
6000 mandeep.dh 27420 
      oprot.writeFieldEnd()
27421 
    if self.ex is not None:
27422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27423 
      self.ex.write(oprot)
27424 
      oprot.writeFieldEnd()
27425 
    oprot.writeFieldStop()
27426 
    oprot.writeStructEnd()
27427 
 
27428 
  def validate(self):
27429 
    return
27430 
 
27431 
 
27432 
  def __repr__(self):
27433 
    L = ['%s=%r' % (key, value)
27434 
      for key, value in self.__dict__.iteritems()]
27435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27436 
 
27437 
  def __eq__(self, other):
27438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27439 
 
27440 
  def __ne__(self, other):
27441 
    return not (self == other)
27442 
 
6031 rajveer 27443 
class getUserWallet_args:
6000 mandeep.dh 27444 
  """
27445 
  Attributes:
6031 rajveer 27446 
   - userId
6000 mandeep.dh 27447 
  """
27448 
 
27449 
  thrift_spec = (
27450 
    None, # 0
6031 rajveer 27451 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27452 
  )
27453 
 
6031 rajveer 27454 
  def __init__(self, userId=None,):
27455 
    self.userId = userId
6000 mandeep.dh 27456 
 
27457 
  def read(self, iprot):
27458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27460 
      return
27461 
    iprot.readStructBegin()
27462 
    while True:
27463 
      (fname, ftype, fid) = iprot.readFieldBegin()
27464 
      if ftype == TType.STOP:
27465 
        break
27466 
      if fid == 1:
27467 
        if ftype == TType.I64:
6031 rajveer 27468 
          self.userId = iprot.readI64();
6000 mandeep.dh 27469 
        else:
27470 
          iprot.skip(ftype)
27471 
      else:
27472 
        iprot.skip(ftype)
27473 
      iprot.readFieldEnd()
27474 
    iprot.readStructEnd()
27475 
 
27476 
  def write(self, oprot):
27477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27479 
      return
6031 rajveer 27480 
    oprot.writeStructBegin('getUserWallet_args')
27481 
    if self.userId is not None:
27482 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27483 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27484 
      oprot.writeFieldEnd()
27485 
    oprot.writeFieldStop()
27486 
    oprot.writeStructEnd()
27487 
 
27488 
  def validate(self):
27489 
    return
27490 
 
27491 
 
27492 
  def __repr__(self):
27493 
    L = ['%s=%r' % (key, value)
27494 
      for key, value in self.__dict__.iteritems()]
27495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27496 
 
27497 
  def __eq__(self, other):
27498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27499 
 
27500 
  def __ne__(self, other):
27501 
    return not (self == other)
27502 
 
6031 rajveer 27503 
class getUserWallet_result:
6000 mandeep.dh 27504 
  """
27505 
  Attributes:
27506 
   - success
27507 
  """
27508 
 
27509 
  thrift_spec = (
6031 rajveer 27510 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27511 
  )
27512 
 
27513 
  def __init__(self, success=None,):
27514 
    self.success = success
27515 
 
27516 
  def read(self, iprot):
27517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27519 
      return
27520 
    iprot.readStructBegin()
27521 
    while True:
27522 
      (fname, ftype, fid) = iprot.readFieldBegin()
27523 
      if ftype == TType.STOP:
27524 
        break
27525 
      if fid == 0:
6031 rajveer 27526 
        if ftype == TType.STRUCT:
27527 
          self.success = UserWallet()
27528 
          self.success.read(iprot)
6000 mandeep.dh 27529 
        else:
27530 
          iprot.skip(ftype)
27531 
      else:
27532 
        iprot.skip(ftype)
27533 
      iprot.readFieldEnd()
27534 
    iprot.readStructEnd()
27535 
 
27536 
  def write(self, oprot):
27537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27539 
      return
6031 rajveer 27540 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27541 
    if self.success is not None:
6031 rajveer 27542 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27543 
      self.success.write(oprot)
6000 mandeep.dh 27544 
      oprot.writeFieldEnd()
27545 
    oprot.writeFieldStop()
27546 
    oprot.writeStructEnd()
27547 
 
27548 
  def validate(self):
27549 
    return
27550 
 
27551 
 
27552 
  def __repr__(self):
27553 
    L = ['%s=%r' % (key, value)
27554 
      for key, value in self.__dict__.iteritems()]
27555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27556 
 
27557 
  def __eq__(self, other):
27558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27559 
 
27560 
  def __ne__(self, other):
27561 
    return not (self == other)
27562 
 
6031 rajveer 27563 
class getUserWalletHistory_args:
6000 mandeep.dh 27564 
  """
27565 
  Attributes:
6031 rajveer 27566 
   - userId
6000 mandeep.dh 27567 
  """
27568 
 
27569 
  thrift_spec = (
27570 
    None, # 0
6031 rajveer 27571 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27572 
  )
27573 
 
6031 rajveer 27574 
  def __init__(self, userId=None,):
27575 
    self.userId = userId
6000 mandeep.dh 27576 
 
27577 
  def read(self, iprot):
27578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27580 
      return
27581 
    iprot.readStructBegin()
27582 
    while True:
27583 
      (fname, ftype, fid) = iprot.readFieldBegin()
27584 
      if ftype == TType.STOP:
27585 
        break
27586 
      if fid == 1:
27587 
        if ftype == TType.I64:
6031 rajveer 27588 
          self.userId = iprot.readI64();
6000 mandeep.dh 27589 
        else:
27590 
          iprot.skip(ftype)
27591 
      else:
27592 
        iprot.skip(ftype)
27593 
      iprot.readFieldEnd()
27594 
    iprot.readStructEnd()
27595 
 
27596 
  def write(self, oprot):
27597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27599 
      return
6031 rajveer 27600 
    oprot.writeStructBegin('getUserWalletHistory_args')
27601 
    if self.userId is not None:
27602 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27603 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27604 
      oprot.writeFieldEnd()
27605 
    oprot.writeFieldStop()
27606 
    oprot.writeStructEnd()
27607 
 
27608 
  def validate(self):
27609 
    return
27610 
 
27611 
 
27612 
  def __repr__(self):
27613 
    L = ['%s=%r' % (key, value)
27614 
      for key, value in self.__dict__.iteritems()]
27615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27616 
 
27617 
  def __eq__(self, other):
27618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27619 
 
27620 
  def __ne__(self, other):
27621 
    return not (self == other)
27622 
 
6031 rajveer 27623 
class getUserWalletHistory_result:
6000 mandeep.dh 27624 
  """
27625 
  Attributes:
27626 
   - success
27627 
  """
27628 
 
27629 
  thrift_spec = (
6031 rajveer 27630 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27631 
  )
27632 
 
27633 
  def __init__(self, success=None,):
27634 
    self.success = success
27635 
 
27636 
  def read(self, iprot):
27637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27639 
      return
27640 
    iprot.readStructBegin()
27641 
    while True:
27642 
      (fname, ftype, fid) = iprot.readFieldBegin()
27643 
      if ftype == TType.STOP:
27644 
        break
27645 
      if fid == 0:
27646 
        if ftype == TType.LIST:
27647 
          self.success = []
6188 rajveer 27648 
          (_etype666, _size663) = iprot.readListBegin()
27649 
          for _i667 in xrange(_size663):
27650 
            _elem668 = UserWalletHistory()
27651 
            _elem668.read(iprot)
27652 
            self.success.append(_elem668)
6000 mandeep.dh 27653 
          iprot.readListEnd()
27654 
        else:
27655 
          iprot.skip(ftype)
27656 
      else:
27657 
        iprot.skip(ftype)
27658 
      iprot.readFieldEnd()
27659 
    iprot.readStructEnd()
27660 
 
27661 
  def write(self, oprot):
27662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27664 
      return
6031 rajveer 27665 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27666 
    if self.success is not None:
27667 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27668 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27669 
      for iter669 in self.success:
27670 
        iter669.write(oprot)
6000 mandeep.dh 27671 
      oprot.writeListEnd()
27672 
      oprot.writeFieldEnd()
27673 
    oprot.writeFieldStop()
27674 
    oprot.writeStructEnd()
27675 
 
27676 
  def validate(self):
27677 
    return
27678 
 
27679 
 
27680 
  def __repr__(self):
27681 
    L = ['%s=%r' % (key, value)
27682 
      for key, value in self.__dict__.iteritems()]
27683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27684 
 
27685 
  def __eq__(self, other):
27686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27687 
 
27688 
  def __ne__(self, other):
27689 
    return not (self == other)
6048 rajveer 27690 
 
6050 anupam.sin 27691 
class getRechargeOrdersForTransaction_args:
27692 
  """
27693 
  Attributes:
27694 
   - txnId
27695 
  """
27696 
 
27697 
  thrift_spec = (
27698 
    None, # 0
27699 
    (1, TType.I64, 'txnId', None, None, ), # 1
27700 
  )
27701 
 
27702 
  def __init__(self, txnId=None,):
27703 
    self.txnId = txnId
27704 
 
27705 
  def read(self, iprot):
27706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27708 
      return
27709 
    iprot.readStructBegin()
27710 
    while True:
27711 
      (fname, ftype, fid) = iprot.readFieldBegin()
27712 
      if ftype == TType.STOP:
27713 
        break
27714 
      if fid == 1:
27715 
        if ftype == TType.I64:
27716 
          self.txnId = iprot.readI64();
27717 
        else:
27718 
          iprot.skip(ftype)
27719 
      else:
27720 
        iprot.skip(ftype)
27721 
      iprot.readFieldEnd()
27722 
    iprot.readStructEnd()
27723 
 
27724 
  def write(self, oprot):
27725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27727 
      return
27728 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27729 
    if self.txnId is not None:
27730 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27731 
      oprot.writeI64(self.txnId)
27732 
      oprot.writeFieldEnd()
27733 
    oprot.writeFieldStop()
27734 
    oprot.writeStructEnd()
27735 
 
27736 
  def validate(self):
27737 
    return
27738 
 
27739 
 
27740 
  def __repr__(self):
27741 
    L = ['%s=%r' % (key, value)
27742 
      for key, value in self.__dict__.iteritems()]
27743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27744 
 
27745 
  def __eq__(self, other):
27746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27747 
 
27748 
  def __ne__(self, other):
27749 
    return not (self == other)
27750 
 
27751 
class getRechargeOrdersForTransaction_result:
27752 
  """
27753 
  Attributes:
27754 
   - success
27755 
   - ex
27756 
  """
27757 
 
27758 
  thrift_spec = (
27759 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27761 
  )
27762 
 
27763 
  def __init__(self, success=None, ex=None,):
27764 
    self.success = success
27765 
    self.ex = ex
27766 
 
27767 
  def read(self, iprot):
27768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27770 
      return
27771 
    iprot.readStructBegin()
27772 
    while True:
27773 
      (fname, ftype, fid) = iprot.readFieldBegin()
27774 
      if ftype == TType.STOP:
27775 
        break
27776 
      if fid == 0:
27777 
        if ftype == TType.STRUCT:
27778 
          self.success = RechargeOrder()
27779 
          self.success.read(iprot)
27780 
        else:
27781 
          iprot.skip(ftype)
27782 
      elif fid == 1:
27783 
        if ftype == TType.STRUCT:
27784 
          self.ex = TransactionServiceException()
27785 
          self.ex.read(iprot)
27786 
        else:
27787 
          iprot.skip(ftype)
27788 
      else:
27789 
        iprot.skip(ftype)
27790 
      iprot.readFieldEnd()
27791 
    iprot.readStructEnd()
27792 
 
27793 
  def write(self, oprot):
27794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27796 
      return
27797 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27798 
    if self.success is not None:
27799 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27800 
      self.success.write(oprot)
27801 
      oprot.writeFieldEnd()
27802 
    if self.ex is not None:
27803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27804 
      self.ex.write(oprot)
27805 
      oprot.writeFieldEnd()
27806 
    oprot.writeFieldStop()
27807 
    oprot.writeStructEnd()
27808 
 
27809 
  def validate(self):
27810 
    return
27811 
 
27812 
 
27813 
  def __repr__(self):
27814 
    L = ['%s=%r' % (key, value)
27815 
      for key, value in self.__dict__.iteritems()]
27816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27817 
 
27818 
  def __eq__(self, other):
27819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27820 
 
27821 
  def __ne__(self, other):
27822 
    return not (self == other)
27823 
 
6048 rajveer 27824 
class getServiceProviders_args:
27825 
  """
27826 
  Attributes:
27827 
   - rechargeType
6206 rajveer 27828 
   - onlyActive
6048 rajveer 27829 
  """
27830 
 
27831 
  thrift_spec = (
27832 
    None, # 0
27833 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27834 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27835 
  )
27836 
 
6206 rajveer 27837 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27838 
    self.rechargeType = rechargeType
6206 rajveer 27839 
    self.onlyActive = onlyActive
6048 rajveer 27840 
 
27841 
  def read(self, iprot):
27842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27844 
      return
27845 
    iprot.readStructBegin()
27846 
    while True:
27847 
      (fname, ftype, fid) = iprot.readFieldBegin()
27848 
      if ftype == TType.STOP:
27849 
        break
27850 
      if fid == 1:
27851 
        if ftype == TType.I32:
27852 
          self.rechargeType = iprot.readI32();
27853 
        else:
27854 
          iprot.skip(ftype)
6206 rajveer 27855 
      elif fid == 2:
27856 
        if ftype == TType.BOOL:
27857 
          self.onlyActive = iprot.readBool();
27858 
        else:
27859 
          iprot.skip(ftype)
6048 rajveer 27860 
      else:
27861 
        iprot.skip(ftype)
27862 
      iprot.readFieldEnd()
27863 
    iprot.readStructEnd()
27864 
 
27865 
  def write(self, oprot):
27866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27868 
      return
27869 
    oprot.writeStructBegin('getServiceProviders_args')
27870 
    if self.rechargeType is not None:
27871 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27872 
      oprot.writeI32(self.rechargeType)
27873 
      oprot.writeFieldEnd()
6206 rajveer 27874 
    if self.onlyActive is not None:
27875 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27876 
      oprot.writeBool(self.onlyActive)
27877 
      oprot.writeFieldEnd()
6048 rajveer 27878 
    oprot.writeFieldStop()
27879 
    oprot.writeStructEnd()
27880 
 
27881 
  def validate(self):
27882 
    return
27883 
 
27884 
 
27885 
  def __repr__(self):
27886 
    L = ['%s=%r' % (key, value)
27887 
      for key, value in self.__dict__.iteritems()]
27888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27889 
 
27890 
  def __eq__(self, other):
27891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27892 
 
27893 
  def __ne__(self, other):
27894 
    return not (self == other)
27895 
 
27896 
class getServiceProviders_result:
27897 
  """
27898 
  Attributes:
27899 
   - success
27900 
  """
27901 
 
27902 
  thrift_spec = (
27903 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27904 
  )
27905 
 
27906 
  def __init__(self, success=None,):
27907 
    self.success = success
27908 
 
27909 
  def read(self, iprot):
27910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27912 
      return
27913 
    iprot.readStructBegin()
27914 
    while True:
27915 
      (fname, ftype, fid) = iprot.readFieldBegin()
27916 
      if ftype == TType.STOP:
27917 
        break
27918 
      if fid == 0:
27919 
        if ftype == TType.MAP:
27920 
          self.success = {}
6188 rajveer 27921 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27922 
          for _i674 in xrange(_size670):
27923 
            _key675 = iprot.readI64();
27924 
            _val676 = iprot.readString();
27925 
            self.success[_key675] = _val676
6048 rajveer 27926 
          iprot.readMapEnd()
27927 
        else:
27928 
          iprot.skip(ftype)
27929 
      else:
27930 
        iprot.skip(ftype)
27931 
      iprot.readFieldEnd()
27932 
    iprot.readStructEnd()
27933 
 
27934 
  def write(self, oprot):
27935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27937 
      return
27938 
    oprot.writeStructBegin('getServiceProviders_result')
27939 
    if self.success is not None:
27940 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27941 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27942 
      for kiter677,viter678 in self.success.items():
27943 
        oprot.writeI64(kiter677)
27944 
        oprot.writeString(viter678)
6048 rajveer 27945 
      oprot.writeMapEnd()
27946 
      oprot.writeFieldEnd()
27947 
    oprot.writeFieldStop()
27948 
    oprot.writeStructEnd()
27949 
 
27950 
  def validate(self):
27951 
    return
27952 
 
27953 
 
27954 
  def __repr__(self):
27955 
    L = ['%s=%r' % (key, value)
27956 
      for key, value in self.__dict__.iteritems()]
27957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27958 
 
27959 
  def __eq__(self, other):
27960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27961 
 
27962 
  def __ne__(self, other):
27963 
    return not (self == other)
27964 
 
27965 
class getServiceProviderForDevice_args:
27966 
  """
27967 
  Attributes:
6049 rajveer 27968 
   - rechargeType
6048 rajveer 27969 
   - deviceNumber
27970 
  """
27971 
 
27972 
  thrift_spec = (
27973 
    None, # 0
6049 rajveer 27974 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27975 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27976 
  )
27977 
 
6049 rajveer 27978 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27979 
    self.rechargeType = rechargeType
6048 rajveer 27980 
    self.deviceNumber = deviceNumber
27981 
 
27982 
  def read(self, iprot):
27983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27985 
      return
27986 
    iprot.readStructBegin()
27987 
    while True:
27988 
      (fname, ftype, fid) = iprot.readFieldBegin()
27989 
      if ftype == TType.STOP:
27990 
        break
27991 
      if fid == 1:
6049 rajveer 27992 
        if ftype == TType.I32:
27993 
          self.rechargeType = iprot.readI32();
27994 
        else:
27995 
          iprot.skip(ftype)
27996 
      elif fid == 2:
6048 rajveer 27997 
        if ftype == TType.STRING:
27998 
          self.deviceNumber = iprot.readString();
27999 
        else:
28000 
          iprot.skip(ftype)
28001 
      else:
28002 
        iprot.skip(ftype)
28003 
      iprot.readFieldEnd()
28004 
    iprot.readStructEnd()
28005 
 
28006 
  def write(self, oprot):
28007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28009 
      return
28010 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28011 
    if self.rechargeType is not None:
28012 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28013 
      oprot.writeI32(self.rechargeType)
28014 
      oprot.writeFieldEnd()
6048 rajveer 28015 
    if self.deviceNumber is not None:
6049 rajveer 28016 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28017 
      oprot.writeString(self.deviceNumber)
28018 
      oprot.writeFieldEnd()
28019 
    oprot.writeFieldStop()
28020 
    oprot.writeStructEnd()
28021 
 
28022 
  def validate(self):
28023 
    return
28024 
 
28025 
 
28026 
  def __repr__(self):
28027 
    L = ['%s=%r' % (key, value)
28028 
      for key, value in self.__dict__.iteritems()]
28029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28030 
 
28031 
  def __eq__(self, other):
28032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28033 
 
28034 
  def __ne__(self, other):
28035 
    return not (self == other)
28036 
 
28037 
class getServiceProviderForDevice_result:
28038 
  """
28039 
  Attributes:
28040 
   - success
28041 
  """
28042 
 
28043 
  thrift_spec = (
6289 anupam.sin 28044 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28045 
  )
28046 
 
28047 
  def __init__(self, success=None,):
28048 
    self.success = success
28049 
 
28050 
  def read(self, iprot):
28051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28053 
      return
28054 
    iprot.readStructBegin()
28055 
    while True:
28056 
      (fname, ftype, fid) = iprot.readFieldBegin()
28057 
      if ftype == TType.STOP:
28058 
        break
28059 
      if fid == 0:
6289 anupam.sin 28060 
        if ftype == TType.STRUCT:
28061 
          self.success = DeviceNumberInfo()
28062 
          self.success.read(iprot)
6048 rajveer 28063 
        else:
28064 
          iprot.skip(ftype)
28065 
      else:
28066 
        iprot.skip(ftype)
28067 
      iprot.readFieldEnd()
28068 
    iprot.readStructEnd()
28069 
 
28070 
  def write(self, oprot):
28071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28073 
      return
28074 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28075 
    if self.success is not None:
6289 anupam.sin 28076 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28077 
      self.success.write(oprot)
6048 rajveer 28078 
      oprot.writeFieldEnd()
28079 
    oprot.writeFieldStop()
28080 
    oprot.writeStructEnd()
28081 
 
28082 
  def validate(self):
28083 
    return
28084 
 
28085 
 
28086 
  def __repr__(self):
28087 
    L = ['%s=%r' % (key, value)
28088 
      for key, value in self.__dict__.iteritems()]
28089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28090 
 
28091 
  def __eq__(self, other):
28092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28093 
 
28094 
  def __ne__(self, other):
28095 
    return not (self == other)
6094 rajveer 28096 
 
6269 rajveer 28097 
class validateRecharge_args:
28098 
  """
28099 
  Attributes:
28100 
   - rechargeType
28101 
   - deviceNumber
6307 anupam.sin 28102 
   - userSelectedProviderId
6591 anupam.sin 28103 
   - clientAddress
6269 rajveer 28104 
  """
28105 
 
28106 
  thrift_spec = (
28107 
    None, # 0
28108 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28109 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28110 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28111 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28112 
  )
28113 
 
6591 anupam.sin 28114 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28115 
    self.rechargeType = rechargeType
28116 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28117 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28118 
    self.clientAddress = clientAddress
6269 rajveer 28119 
 
28120 
  def read(self, iprot):
28121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28123 
      return
28124 
    iprot.readStructBegin()
28125 
    while True:
28126 
      (fname, ftype, fid) = iprot.readFieldBegin()
28127 
      if ftype == TType.STOP:
28128 
        break
28129 
      if fid == 1:
28130 
        if ftype == TType.I32:
28131 
          self.rechargeType = iprot.readI32();
28132 
        else:
28133 
          iprot.skip(ftype)
28134 
      elif fid == 2:
28135 
        if ftype == TType.STRING:
28136 
          self.deviceNumber = iprot.readString();
28137 
        else:
28138 
          iprot.skip(ftype)
6307 anupam.sin 28139 
      elif fid == 3:
28140 
        if ftype == TType.I64:
28141 
          self.userSelectedProviderId = iprot.readI64();
28142 
        else:
28143 
          iprot.skip(ftype)
6591 anupam.sin 28144 
      elif fid == 4:
28145 
        if ftype == TType.STRING:
28146 
          self.clientAddress = iprot.readString();
28147 
        else:
28148 
          iprot.skip(ftype)
6269 rajveer 28149 
      else:
28150 
        iprot.skip(ftype)
28151 
      iprot.readFieldEnd()
28152 
    iprot.readStructEnd()
28153 
 
28154 
  def write(self, oprot):
28155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28157 
      return
28158 
    oprot.writeStructBegin('validateRecharge_args')
28159 
    if self.rechargeType is not None:
28160 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28161 
      oprot.writeI32(self.rechargeType)
28162 
      oprot.writeFieldEnd()
28163 
    if self.deviceNumber is not None:
28164 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28165 
      oprot.writeString(self.deviceNumber)
28166 
      oprot.writeFieldEnd()
6307 anupam.sin 28167 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28168 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28169 
      oprot.writeI64(self.userSelectedProviderId)
28170 
      oprot.writeFieldEnd()
6591 anupam.sin 28171 
    if self.clientAddress is not None:
28172 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28173 
      oprot.writeString(self.clientAddress)
28174 
      oprot.writeFieldEnd()
6269 rajveer 28175 
    oprot.writeFieldStop()
28176 
    oprot.writeStructEnd()
28177 
 
28178 
  def validate(self):
28179 
    return
28180 
 
28181 
 
28182 
  def __repr__(self):
28183 
    L = ['%s=%r' % (key, value)
28184 
      for key, value in self.__dict__.iteritems()]
28185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28186 
 
28187 
  def __eq__(self, other):
28188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28189 
 
28190 
  def __ne__(self, other):
28191 
    return not (self == other)
28192 
 
28193 
class validateRecharge_result:
28194 
  """
28195 
  Attributes:
28196 
   - success
28197 
  """
28198 
 
28199 
  thrift_spec = (
28200 
    (0, TType.STRING, 'success', None, None, ), # 0
28201 
  )
28202 
 
28203 
  def __init__(self, success=None,):
28204 
    self.success = success
28205 
 
28206 
  def read(self, iprot):
28207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28209 
      return
28210 
    iprot.readStructBegin()
28211 
    while True:
28212 
      (fname, ftype, fid) = iprot.readFieldBegin()
28213 
      if ftype == TType.STOP:
28214 
        break
28215 
      if fid == 0:
28216 
        if ftype == TType.STRING:
28217 
          self.success = iprot.readString();
28218 
        else:
28219 
          iprot.skip(ftype)
28220 
      else:
28221 
        iprot.skip(ftype)
28222 
      iprot.readFieldEnd()
28223 
    iprot.readStructEnd()
28224 
 
28225 
  def write(self, oprot):
28226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28228 
      return
28229 
    oprot.writeStructBegin('validateRecharge_result')
28230 
    if self.success is not None:
28231 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28232 
      oprot.writeString(self.success)
28233 
      oprot.writeFieldEnd()
28234 
    oprot.writeFieldStop()
28235 
    oprot.writeStructEnd()
28236 
 
28237 
  def validate(self):
28238 
    return
28239 
 
28240 
 
28241 
  def __repr__(self):
28242 
    L = ['%s=%r' % (key, value)
28243 
      for key, value in self.__dict__.iteritems()]
28244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28245 
 
28246 
  def __eq__(self, other):
28247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28248 
 
28249 
  def __ne__(self, other):
28250 
    return not (self == other)
28251 
 
6094 rajveer 28252 
class getRechargeOrdersForDevice_args:
28253 
  """
28254 
  Attributes:
28255 
   - deviceNumber
28256 
  """
28257 
 
28258 
  thrift_spec = (
28259 
    None, # 0
28260 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28261 
  )
28262 
 
28263 
  def __init__(self, deviceNumber=None,):
28264 
    self.deviceNumber = deviceNumber
28265 
 
28266 
  def read(self, iprot):
28267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28269 
      return
28270 
    iprot.readStructBegin()
28271 
    while True:
28272 
      (fname, ftype, fid) = iprot.readFieldBegin()
28273 
      if ftype == TType.STOP:
28274 
        break
28275 
      if fid == 1:
28276 
        if ftype == TType.STRING:
28277 
          self.deviceNumber = iprot.readString();
28278 
        else:
28279 
          iprot.skip(ftype)
28280 
      else:
28281 
        iprot.skip(ftype)
28282 
      iprot.readFieldEnd()
28283 
    iprot.readStructEnd()
28284 
 
28285 
  def write(self, oprot):
28286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28288 
      return
28289 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28290 
    if self.deviceNumber is not None:
28291 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28292 
      oprot.writeString(self.deviceNumber)
28293 
      oprot.writeFieldEnd()
28294 
    oprot.writeFieldStop()
28295 
    oprot.writeStructEnd()
28296 
 
28297 
  def validate(self):
28298 
    return
28299 
 
28300 
 
28301 
  def __repr__(self):
28302 
    L = ['%s=%r' % (key, value)
28303 
      for key, value in self.__dict__.iteritems()]
28304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28305 
 
28306 
  def __eq__(self, other):
28307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28308 
 
28309 
  def __ne__(self, other):
28310 
    return not (self == other)
28311 
 
28312 
class getRechargeOrdersForDevice_result:
28313 
  """
28314 
  Attributes:
28315 
   - success
28316 
  """
28317 
 
28318 
  thrift_spec = (
28319 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28320 
  )
28321 
 
28322 
  def __init__(self, success=None,):
28323 
    self.success = success
28324 
 
28325 
  def read(self, iprot):
28326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28328 
      return
28329 
    iprot.readStructBegin()
28330 
    while True:
28331 
      (fname, ftype, fid) = iprot.readFieldBegin()
28332 
      if ftype == TType.STOP:
28333 
        break
28334 
      if fid == 0:
28335 
        if ftype == TType.LIST:
28336 
          self.success = []
6188 rajveer 28337 
          (_etype682, _size679) = iprot.readListBegin()
28338 
          for _i683 in xrange(_size679):
28339 
            _elem684 = RechargeOrder()
28340 
            _elem684.read(iprot)
28341 
            self.success.append(_elem684)
6094 rajveer 28342 
          iprot.readListEnd()
28343 
        else:
28344 
          iprot.skip(ftype)
28345 
      else:
28346 
        iprot.skip(ftype)
28347 
      iprot.readFieldEnd()
28348 
    iprot.readStructEnd()
28349 
 
28350 
  def write(self, oprot):
28351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28353 
      return
28354 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28355 
    if self.success is not None:
28356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28358 
      for iter685 in self.success:
28359 
        iter685.write(oprot)
6094 rajveer 28360 
      oprot.writeListEnd()
28361 
      oprot.writeFieldEnd()
28362 
    oprot.writeFieldStop()
28363 
    oprot.writeStructEnd()
28364 
 
28365 
  def validate(self):
28366 
    return
28367 
 
28368 
 
28369 
  def __repr__(self):
28370 
    L = ['%s=%r' % (key, value)
28371 
      for key, value in self.__dict__.iteritems()]
28372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28373 
 
28374 
  def __eq__(self, other):
28375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28376 
 
28377 
  def __ne__(self, other):
28378 
    return not (self == other)
28379 
 
28380 
class addAmountToWallet_args:
28381 
  """
28382 
  Attributes:
28383 
   - userId
28384 
   - orderId
28385 
   - amount
28386 
  """
28387 
 
28388 
  thrift_spec = (
28389 
    None, # 0
28390 
    (1, TType.I64, 'userId', None, None, ), # 1
28391 
    (2, TType.I64, 'orderId', None, None, ), # 2
28392 
    (3, TType.I64, 'amount', None, None, ), # 3
28393 
  )
28394 
 
28395 
  def __init__(self, userId=None, orderId=None, amount=None,):
28396 
    self.userId = userId
28397 
    self.orderId = orderId
28398 
    self.amount = amount
28399 
 
28400 
  def read(self, iprot):
28401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28403 
      return
28404 
    iprot.readStructBegin()
28405 
    while True:
28406 
      (fname, ftype, fid) = iprot.readFieldBegin()
28407 
      if ftype == TType.STOP:
28408 
        break
28409 
      if fid == 1:
28410 
        if ftype == TType.I64:
28411 
          self.userId = iprot.readI64();
28412 
        else:
28413 
          iprot.skip(ftype)
28414 
      elif fid == 2:
28415 
        if ftype == TType.I64:
28416 
          self.orderId = iprot.readI64();
28417 
        else:
28418 
          iprot.skip(ftype)
28419 
      elif fid == 3:
28420 
        if ftype == TType.I64:
28421 
          self.amount = iprot.readI64();
28422 
        else:
28423 
          iprot.skip(ftype)
28424 
      else:
28425 
        iprot.skip(ftype)
28426 
      iprot.readFieldEnd()
28427 
    iprot.readStructEnd()
28428 
 
28429 
  def write(self, oprot):
28430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28432 
      return
28433 
    oprot.writeStructBegin('addAmountToWallet_args')
28434 
    if self.userId is not None:
28435 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28436 
      oprot.writeI64(self.userId)
28437 
      oprot.writeFieldEnd()
28438 
    if self.orderId is not None:
28439 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28440 
      oprot.writeI64(self.orderId)
28441 
      oprot.writeFieldEnd()
28442 
    if self.amount is not None:
28443 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28444 
      oprot.writeI64(self.amount)
28445 
      oprot.writeFieldEnd()
28446 
    oprot.writeFieldStop()
28447 
    oprot.writeStructEnd()
28448 
 
28449 
  def validate(self):
28450 
    return
28451 
 
28452 
 
28453 
  def __repr__(self):
28454 
    L = ['%s=%r' % (key, value)
28455 
      for key, value in self.__dict__.iteritems()]
28456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28457 
 
28458 
  def __eq__(self, other):
28459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28460 
 
28461 
  def __ne__(self, other):
28462 
    return not (self == other)
28463 
 
28464 
class addAmountToWallet_result:
28465 
 
28466 
  thrift_spec = (
28467 
  )
28468 
 
28469 
  def read(self, iprot):
28470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28472 
      return
28473 
    iprot.readStructBegin()
28474 
    while True:
28475 
      (fname, ftype, fid) = iprot.readFieldBegin()
28476 
      if ftype == TType.STOP:
28477 
        break
28478 
      else:
28479 
        iprot.skip(ftype)
28480 
      iprot.readFieldEnd()
28481 
    iprot.readStructEnd()
28482 
 
28483 
  def write(self, oprot):
28484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28486 
      return
28487 
    oprot.writeStructBegin('addAmountToWallet_result')
28488 
    oprot.writeFieldStop()
28489 
    oprot.writeStructEnd()
28490 
 
28491 
  def validate(self):
28492 
    return
28493 
 
28494 
 
28495 
  def __repr__(self):
28496 
    L = ['%s=%r' % (key, value)
28497 
      for key, value in self.__dict__.iteritems()]
28498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28499 
 
28500 
  def __eq__(self, other):
28501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28502 
 
28503 
  def __ne__(self, other):
28504 
    return not (self == other)
6154 rajveer 28505 
 
6188 rajveer 28506 
class getRechargeStatistics_args:
28507 
 
28508 
  thrift_spec = (
28509 
  )
28510 
 
28511 
  def read(self, iprot):
28512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28514 
      return
28515 
    iprot.readStructBegin()
28516 
    while True:
28517 
      (fname, ftype, fid) = iprot.readFieldBegin()
28518 
      if ftype == TType.STOP:
28519 
        break
28520 
      else:
28521 
        iprot.skip(ftype)
28522 
      iprot.readFieldEnd()
28523 
    iprot.readStructEnd()
28524 
 
28525 
  def write(self, oprot):
28526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28528 
      return
28529 
    oprot.writeStructBegin('getRechargeStatistics_args')
28530 
    oprot.writeFieldStop()
28531 
    oprot.writeStructEnd()
28532 
 
28533 
  def validate(self):
28534 
    return
28535 
 
28536 
 
28537 
  def __repr__(self):
28538 
    L = ['%s=%r' % (key, value)
28539 
      for key, value in self.__dict__.iteritems()]
28540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28541 
 
28542 
  def __eq__(self, other):
28543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28544 
 
28545 
  def __ne__(self, other):
28546 
    return not (self == other)
28547 
 
28548 
class getRechargeStatistics_result:
28549 
  """
28550 
  Attributes:
28551 
   - success
28552 
  """
28553 
 
28554 
  thrift_spec = (
28555 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28556 
  )
28557 
 
28558 
  def __init__(self, success=None,):
28559 
    self.success = success
28560 
 
28561 
  def read(self, iprot):
28562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28564 
      return
28565 
    iprot.readStructBegin()
28566 
    while True:
28567 
      (fname, ftype, fid) = iprot.readFieldBegin()
28568 
      if ftype == TType.STOP:
28569 
        break
28570 
      if fid == 0:
28571 
        if ftype == TType.STRUCT:
28572 
          self.success = RechargeStatistics()
28573 
          self.success.read(iprot)
28574 
        else:
28575 
          iprot.skip(ftype)
28576 
      else:
28577 
        iprot.skip(ftype)
28578 
      iprot.readFieldEnd()
28579 
    iprot.readStructEnd()
28580 
 
28581 
  def write(self, oprot):
28582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28584 
      return
28585 
    oprot.writeStructBegin('getRechargeStatistics_result')
28586 
    if self.success is not None:
28587 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28588 
      self.success.write(oprot)
28589 
      oprot.writeFieldEnd()
28590 
    oprot.writeFieldStop()
28591 
    oprot.writeStructEnd()
28592 
 
28593 
  def validate(self):
28594 
    return
28595 
 
28596 
 
28597 
  def __repr__(self):
28598 
    L = ['%s=%r' % (key, value)
28599 
      for key, value in self.__dict__.iteritems()]
28600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28601 
 
28602 
  def __eq__(self, other):
28603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28604 
 
28605 
  def __ne__(self, other):
28606 
    return not (self == other)
28607 
 
6154 rajveer 28608 
class getRechargeOrdersForStatus_args:
28609 
  """
28610 
  Attributes:
28611 
   - status
28612 
  """
28613 
 
28614 
  thrift_spec = (
28615 
    None, # 0
28616 
    (1, TType.I64, 'status', None, None, ), # 1
28617 
  )
28618 
 
28619 
  def __init__(self, status=None,):
28620 
    self.status = status
28621 
 
28622 
  def read(self, iprot):
28623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28625 
      return
28626 
    iprot.readStructBegin()
28627 
    while True:
28628 
      (fname, ftype, fid) = iprot.readFieldBegin()
28629 
      if ftype == TType.STOP:
28630 
        break
28631 
      if fid == 1:
28632 
        if ftype == TType.I64:
28633 
          self.status = iprot.readI64();
28634 
        else:
28635 
          iprot.skip(ftype)
28636 
      else:
28637 
        iprot.skip(ftype)
28638 
      iprot.readFieldEnd()
28639 
    iprot.readStructEnd()
28640 
 
28641 
  def write(self, oprot):
28642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28644 
      return
28645 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28646 
    if self.status is not None:
28647 
      oprot.writeFieldBegin('status', TType.I64, 1)
28648 
      oprot.writeI64(self.status)
28649 
      oprot.writeFieldEnd()
28650 
    oprot.writeFieldStop()
28651 
    oprot.writeStructEnd()
28652 
 
28653 
  def validate(self):
28654 
    return
28655 
 
28656 
 
28657 
  def __repr__(self):
28658 
    L = ['%s=%r' % (key, value)
28659 
      for key, value in self.__dict__.iteritems()]
28660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28661 
 
28662 
  def __eq__(self, other):
28663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28664 
 
28665 
  def __ne__(self, other):
28666 
    return not (self == other)
28667 
 
28668 
class getRechargeOrdersForStatus_result:
28669 
  """
28670 
  Attributes:
28671 
   - success
28672 
  """
28673 
 
28674 
  thrift_spec = (
28675 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28676 
  )
28677 
 
28678 
  def __init__(self, success=None,):
28679 
    self.success = success
28680 
 
28681 
  def read(self, iprot):
28682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28684 
      return
28685 
    iprot.readStructBegin()
28686 
    while True:
28687 
      (fname, ftype, fid) = iprot.readFieldBegin()
28688 
      if ftype == TType.STOP:
28689 
        break
28690 
      if fid == 0:
28691 
        if ftype == TType.LIST:
28692 
          self.success = []
6188 rajveer 28693 
          (_etype689, _size686) = iprot.readListBegin()
28694 
          for _i690 in xrange(_size686):
28695 
            _elem691 = RechargeOrder()
28696 
            _elem691.read(iprot)
28697 
            self.success.append(_elem691)
6154 rajveer 28698 
          iprot.readListEnd()
28699 
        else:
28700 
          iprot.skip(ftype)
28701 
      else:
28702 
        iprot.skip(ftype)
28703 
      iprot.readFieldEnd()
28704 
    iprot.readStructEnd()
28705 
 
28706 
  def write(self, oprot):
28707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28709 
      return
28710 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28711 
    if self.success is not None:
28712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28713 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28714 
      for iter692 in self.success:
28715 
        iter692.write(oprot)
6154 rajveer 28716 
      oprot.writeListEnd()
28717 
      oprot.writeFieldEnd()
28718 
    oprot.writeFieldStop()
28719 
    oprot.writeStructEnd()
28720 
 
28721 
  def validate(self):
28722 
    return
28723 
 
28724 
 
28725 
  def __repr__(self):
28726 
    L = ['%s=%r' % (key, value)
28727 
      for key, value in self.__dict__.iteritems()]
28728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28729 
 
28730 
  def __eq__(self, other):
28731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28732 
 
28733 
  def __ne__(self, other):
28734 
    return not (self == other)
6159 rajveer 28735 
 
28736 
class getPlansForOperator_args:
28737 
  """
28738 
  Attributes:
28739 
   - operatorId
28740 
  """
28741 
 
28742 
  thrift_spec = (
28743 
    None, # 0
28744 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28745 
  )
28746 
 
28747 
  def __init__(self, operatorId=None,):
28748 
    self.operatorId = operatorId
28749 
 
28750 
  def read(self, iprot):
28751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28753 
      return
28754 
    iprot.readStructBegin()
28755 
    while True:
28756 
      (fname, ftype, fid) = iprot.readFieldBegin()
28757 
      if ftype == TType.STOP:
28758 
        break
28759 
      if fid == 1:
28760 
        if ftype == TType.I64:
28761 
          self.operatorId = iprot.readI64();
28762 
        else:
28763 
          iprot.skip(ftype)
28764 
      else:
28765 
        iprot.skip(ftype)
28766 
      iprot.readFieldEnd()
28767 
    iprot.readStructEnd()
28768 
 
28769 
  def write(self, oprot):
28770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28772 
      return
28773 
    oprot.writeStructBegin('getPlansForOperator_args')
28774 
    if self.operatorId is not None:
28775 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28776 
      oprot.writeI64(self.operatorId)
28777 
      oprot.writeFieldEnd()
28778 
    oprot.writeFieldStop()
28779 
    oprot.writeStructEnd()
28780 
 
28781 
  def validate(self):
28782 
    return
28783 
 
28784 
 
28785 
  def __repr__(self):
28786 
    L = ['%s=%r' % (key, value)
28787 
      for key, value in self.__dict__.iteritems()]
28788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28789 
 
28790 
  def __eq__(self, other):
28791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28792 
 
28793 
  def __ne__(self, other):
28794 
    return not (self == other)
28795 
 
28796 
class getPlansForOperator_result:
28797 
  """
28798 
  Attributes:
28799 
   - success
28800 
  """
28801 
 
28802 
  thrift_spec = (
28803 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28804 
  )
28805 
 
28806 
  def __init__(self, success=None,):
28807 
    self.success = success
28808 
 
28809 
  def read(self, iprot):
28810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28812 
      return
28813 
    iprot.readStructBegin()
28814 
    while True:
28815 
      (fname, ftype, fid) = iprot.readFieldBegin()
28816 
      if ftype == TType.STOP:
28817 
        break
28818 
      if fid == 0:
28819 
        if ftype == TType.LIST:
28820 
          self.success = []
6188 rajveer 28821 
          (_etype696, _size693) = iprot.readListBegin()
28822 
          for _i697 in xrange(_size693):
28823 
            _elem698 = RechargePlan()
28824 
            _elem698.read(iprot)
28825 
            self.success.append(_elem698)
6159 rajveer 28826 
          iprot.readListEnd()
28827 
        else:
28828 
          iprot.skip(ftype)
28829 
      else:
28830 
        iprot.skip(ftype)
28831 
      iprot.readFieldEnd()
28832 
    iprot.readStructEnd()
28833 
 
28834 
  def write(self, oprot):
28835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28837 
      return
28838 
    oprot.writeStructBegin('getPlansForOperator_result')
28839 
    if self.success is not None:
28840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28842 
      for iter699 in self.success:
28843 
        iter699.write(oprot)
6159 rajveer 28844 
      oprot.writeListEnd()
28845 
      oprot.writeFieldEnd()
28846 
    oprot.writeFieldStop()
28847 
    oprot.writeStructEnd()
28848 
 
28849 
  def validate(self):
28850 
    return
28851 
 
28852 
 
28853 
  def __repr__(self):
28854 
    L = ['%s=%r' % (key, value)
28855 
      for key, value in self.__dict__.iteritems()]
28856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28857 
 
28858 
  def __eq__(self, other):
28859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28860 
 
28861 
  def __ne__(self, other):
28862 
    return not (self == other)
6289 anupam.sin 28863 
 
28864 
class getRechargeDenominations_args:
28865 
  """
28866 
  Attributes:
28867 
   - operatorId
6307 anupam.sin 28868 
   - circleCode
6289 anupam.sin 28869 
   - denominationType
28870 
  """
28871 
 
28872 
  thrift_spec = (
28873 
    None, # 0
28874 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28875 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28876 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28877 
  )
28878 
 
6307 anupam.sin 28879 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28880 
    self.operatorId = operatorId
6307 anupam.sin 28881 
    self.circleCode = circleCode
6289 anupam.sin 28882 
    self.denominationType = denominationType
28883 
 
28884 
  def read(self, iprot):
28885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28887 
      return
28888 
    iprot.readStructBegin()
28889 
    while True:
28890 
      (fname, ftype, fid) = iprot.readFieldBegin()
28891 
      if ftype == TType.STOP:
28892 
        break
28893 
      if fid == 1:
28894 
        if ftype == TType.I64:
28895 
          self.operatorId = iprot.readI64();
28896 
        else:
28897 
          iprot.skip(ftype)
28898 
      elif fid == 2:
28899 
        if ftype == TType.STRING:
6307 anupam.sin 28900 
          self.circleCode = iprot.readString();
6289 anupam.sin 28901 
        else:
28902 
          iprot.skip(ftype)
28903 
      elif fid == 3:
28904 
        if ftype == TType.I32:
28905 
          self.denominationType = iprot.readI32();
28906 
        else:
28907 
          iprot.skip(ftype)
28908 
      else:
28909 
        iprot.skip(ftype)
28910 
      iprot.readFieldEnd()
28911 
    iprot.readStructEnd()
28912 
 
28913 
  def write(self, oprot):
28914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28916 
      return
28917 
    oprot.writeStructBegin('getRechargeDenominations_args')
28918 
    if self.operatorId is not None:
28919 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28920 
      oprot.writeI64(self.operatorId)
28921 
      oprot.writeFieldEnd()
6307 anupam.sin 28922 
    if self.circleCode is not None:
28923 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28924 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28925 
      oprot.writeFieldEnd()
28926 
    if self.denominationType is not None:
28927 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28928 
      oprot.writeI32(self.denominationType)
28929 
      oprot.writeFieldEnd()
28930 
    oprot.writeFieldStop()
28931 
    oprot.writeStructEnd()
28932 
 
28933 
  def validate(self):
28934 
    return
28935 
 
28936 
 
28937 
  def __repr__(self):
28938 
    L = ['%s=%r' % (key, value)
28939 
      for key, value in self.__dict__.iteritems()]
28940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28941 
 
28942 
  def __eq__(self, other):
28943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28944 
 
28945 
  def __ne__(self, other):
28946 
    return not (self == other)
28947 
 
28948 
class getRechargeDenominations_result:
28949 
  """
28950 
  Attributes:
28951 
   - success
28952 
   - ex
28953 
  """
28954 
 
28955 
  thrift_spec = (
28956 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28958 
  )
28959 
 
28960 
  def __init__(self, success=None, ex=None,):
28961 
    self.success = success
28962 
    self.ex = ex
28963 
 
28964 
  def read(self, iprot):
28965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28967 
      return
28968 
    iprot.readStructBegin()
28969 
    while True:
28970 
      (fname, ftype, fid) = iprot.readFieldBegin()
28971 
      if ftype == TType.STOP:
28972 
        break
28973 
      if fid == 0:
28974 
        if ftype == TType.LIST:
28975 
          self.success = []
28976 
          (_etype703, _size700) = iprot.readListBegin()
28977 
          for _i704 in xrange(_size700):
28978 
            _elem705 = RechargeDenomination()
28979 
            _elem705.read(iprot)
28980 
            self.success.append(_elem705)
28981 
          iprot.readListEnd()
28982 
        else:
28983 
          iprot.skip(ftype)
28984 
      elif fid == 1:
28985 
        if ftype == TType.STRUCT:
28986 
          self.ex = TransactionServiceException()
28987 
          self.ex.read(iprot)
28988 
        else:
28989 
          iprot.skip(ftype)
28990 
      else:
28991 
        iprot.skip(ftype)
28992 
      iprot.readFieldEnd()
28993 
    iprot.readStructEnd()
28994 
 
28995 
  def write(self, oprot):
28996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28998 
      return
28999 
    oprot.writeStructBegin('getRechargeDenominations_result')
29000 
    if self.success is not None:
29001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29003 
      for iter706 in self.success:
29004 
        iter706.write(oprot)
29005 
      oprot.writeListEnd()
29006 
      oprot.writeFieldEnd()
29007 
    if self.ex is not None:
29008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29009 
      self.ex.write(oprot)
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)
6371 rajveer 29028 
 
29029 
class updateAvailabilityStatus_args:
29030 
  """
29031 
  Attributes:
29032 
   - operatorId
29033 
   - circleId
29034 
   - isAvailable
29035 
  """
29036 
 
29037 
  thrift_spec = (
29038 
    None, # 0
29039 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29040 
    (2, TType.I64, 'circleId', None, None, ), # 2
29041 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29042 
  )
29043 
 
29044 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29045 
    self.operatorId = operatorId
29046 
    self.circleId = circleId
29047 
    self.isAvailable = isAvailable
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.I64:
29065 
          self.circleId = iprot.readI64();
29066 
        else:
29067 
          iprot.skip(ftype)
29068 
      elif fid == 3:
29069 
        if ftype == TType.BOOL:
29070 
          self.isAvailable = iprot.readBool();
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('updateAvailabilityStatus_args')
29083 
    if self.operatorId is not None:
29084 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29085 
      oprot.writeI64(self.operatorId)
29086 
      oprot.writeFieldEnd()
29087 
    if self.circleId is not None:
29088 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29089 
      oprot.writeI64(self.circleId)
29090 
      oprot.writeFieldEnd()
29091 
    if self.isAvailable is not None:
29092 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29093 
      oprot.writeBool(self.isAvailable)
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 updateAvailabilityStatus_result:
29114 
 
29115 
  thrift_spec = (
29116 
  )
29117 
 
29118 
  def read(self, iprot):
29119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29121 
      return
29122 
    iprot.readStructBegin()
29123 
    while True:
29124 
      (fname, ftype, fid) = iprot.readFieldBegin()
29125 
      if ftype == TType.STOP:
29126 
        break
29127 
      else:
29128 
        iprot.skip(ftype)
29129 
      iprot.readFieldEnd()
29130 
    iprot.readStructEnd()
29131 
 
29132 
  def write(self, oprot):
29133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29135 
      return
29136 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29137 
    oprot.writeFieldStop()
29138 
    oprot.writeStructEnd()
29139 
 
29140 
  def validate(self):
29141 
    return
29142 
 
29143 
 
29144 
  def __repr__(self):
29145 
    L = ['%s=%r' % (key, value)
29146 
      for key, value in self.__dict__.iteritems()]
29147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29148 
 
29149 
  def __eq__(self, other):
29150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29151 
 
29152 
  def __ne__(self, other):
29153 
    return not (self == other)
6389 rajveer 29154 
 
29155 
class getAvailableEmiSchemes_args:
29156 
 
29157 
  thrift_spec = (
29158 
  )
29159 
 
29160 
  def read(self, iprot):
29161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29163 
      return
29164 
    iprot.readStructBegin()
29165 
    while True:
29166 
      (fname, ftype, fid) = iprot.readFieldBegin()
29167 
      if ftype == TType.STOP:
29168 
        break
29169 
      else:
29170 
        iprot.skip(ftype)
29171 
      iprot.readFieldEnd()
29172 
    iprot.readStructEnd()
29173 
 
29174 
  def write(self, oprot):
29175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29177 
      return
29178 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29179 
    oprot.writeFieldStop()
29180 
    oprot.writeStructEnd()
29181 
 
29182 
  def validate(self):
29183 
    return
29184 
 
29185 
 
29186 
  def __repr__(self):
29187 
    L = ['%s=%r' % (key, value)
29188 
      for key, value in self.__dict__.iteritems()]
29189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29190 
 
29191 
  def __eq__(self, other):
29192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29193 
 
29194 
  def __ne__(self, other):
29195 
    return not (self == other)
29196 
 
29197 
class getAvailableEmiSchemes_result:
29198 
  """
29199 
  Attributes:
29200 
   - success
29201 
  """
29202 
 
29203 
  thrift_spec = (
29204 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29205 
  )
29206 
 
29207 
  def __init__(self, success=None,):
29208 
    self.success = success
29209 
 
29210 
  def read(self, iprot):
29211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29213 
      return
29214 
    iprot.readStructBegin()
29215 
    while True:
29216 
      (fname, ftype, fid) = iprot.readFieldBegin()
29217 
      if ftype == TType.STOP:
29218 
        break
29219 
      if fid == 0:
29220 
        if ftype == TType.LIST:
29221 
          self.success = []
29222 
          (_etype710, _size707) = iprot.readListBegin()
29223 
          for _i711 in xrange(_size707):
29224 
            _elem712 = EmiScheme()
29225 
            _elem712.read(iprot)
29226 
            self.success.append(_elem712)
29227 
          iprot.readListEnd()
29228 
        else:
29229 
          iprot.skip(ftype)
29230 
      else:
29231 
        iprot.skip(ftype)
29232 
      iprot.readFieldEnd()
29233 
    iprot.readStructEnd()
29234 
 
29235 
  def write(self, oprot):
29236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29238 
      return
29239 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29240 
    if self.success is not None:
29241 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29242 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29243 
      for iter713 in self.success:
29244 
        iter713.write(oprot)
29245 
      oprot.writeListEnd()
29246 
      oprot.writeFieldEnd()
29247 
    oprot.writeFieldStop()
29248 
    oprot.writeStructEnd()
29249 
 
29250 
  def validate(self):
29251 
    return
29252 
 
29253 
 
29254 
  def __repr__(self):
29255 
    L = ['%s=%r' % (key, value)
29256 
      for key, value in self.__dict__.iteritems()]
29257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29258 
 
29259 
  def __eq__(self, other):
29260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29261 
 
29262 
  def __ne__(self, other):
29263 
    return not (self == other)
29264 
 
29265 
class getMiscCharges_args:
29266 
  """
29267 
  Attributes:
29268 
   - transactionId
29269 
  """
29270 
 
29271 
  thrift_spec = (
29272 
    None, # 0
29273 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29274 
  )
29275 
 
29276 
  def __init__(self, transactionId=None,):
29277 
    self.transactionId = transactionId
29278 
 
29279 
  def read(self, iprot):
29280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29282 
      return
29283 
    iprot.readStructBegin()
29284 
    while True:
29285 
      (fname, ftype, fid) = iprot.readFieldBegin()
29286 
      if ftype == TType.STOP:
29287 
        break
29288 
      if fid == 1:
29289 
        if ftype == TType.I64:
29290 
          self.transactionId = iprot.readI64();
29291 
        else:
29292 
          iprot.skip(ftype)
29293 
      else:
29294 
        iprot.skip(ftype)
29295 
      iprot.readFieldEnd()
29296 
    iprot.readStructEnd()
29297 
 
29298 
  def write(self, oprot):
29299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29301 
      return
29302 
    oprot.writeStructBegin('getMiscCharges_args')
29303 
    if self.transactionId is not None:
29304 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29305 
      oprot.writeI64(self.transactionId)
29306 
      oprot.writeFieldEnd()
29307 
    oprot.writeFieldStop()
29308 
    oprot.writeStructEnd()
29309 
 
29310 
  def validate(self):
29311 
    return
29312 
 
29313 
 
29314 
  def __repr__(self):
29315 
    L = ['%s=%r' % (key, value)
29316 
      for key, value in self.__dict__.iteritems()]
29317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29318 
 
29319 
  def __eq__(self, other):
29320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29321 
 
29322 
  def __ne__(self, other):
29323 
    return not (self == other)
29324 
 
29325 
class getMiscCharges_result:
29326 
  """
29327 
  Attributes:
29328 
   - success
29329 
  """
29330 
 
29331 
  thrift_spec = (
6412 rajveer 29332 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29333 
  )
29334 
 
29335 
  def __init__(self, success=None,):
29336 
    self.success = success
29337 
 
29338 
  def read(self, iprot):
29339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29341 
      return
29342 
    iprot.readStructBegin()
29343 
    while True:
29344 
      (fname, ftype, fid) = iprot.readFieldBegin()
29345 
      if ftype == TType.STOP:
29346 
        break
29347 
      if fid == 0:
29348 
        if ftype == TType.MAP:
29349 
          self.success = {}
29350 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29351 
          for _i718 in xrange(_size714):
29352 
            _key719 = iprot.readI64();
6412 rajveer 29353 
            _val720 = iprot.readDouble();
6389 rajveer 29354 
            self.success[_key719] = _val720
29355 
          iprot.readMapEnd()
29356 
        else:
29357 
          iprot.skip(ftype)
29358 
      else:
29359 
        iprot.skip(ftype)
29360 
      iprot.readFieldEnd()
29361 
    iprot.readStructEnd()
29362 
 
29363 
  def write(self, oprot):
29364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29366 
      return
29367 
    oprot.writeStructBegin('getMiscCharges_result')
29368 
    if self.success is not None:
29369 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29370 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29371 
      for kiter721,viter722 in self.success.items():
29372 
        oprot.writeI64(kiter721)
6412 rajveer 29373 
        oprot.writeDouble(viter722)
6389 rajveer 29374 
      oprot.writeMapEnd()
29375 
      oprot.writeFieldEnd()
29376 
    oprot.writeFieldStop()
29377 
    oprot.writeStructEnd()
29378 
 
29379 
  def validate(self):
29380 
    return
29381 
 
29382 
 
29383 
  def __repr__(self):
29384 
    L = ['%s=%r' % (key, value)
29385 
      for key, value in self.__dict__.iteritems()]
29386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29387 
 
29388 
  def __eq__(self, other):
29389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29390 
 
29391 
  def __ne__(self, other):
29392 
    return not (self == other)
6507 anupam.sin 29393 
 
29394 
class refundRechargeOrder_args:
29395 
  """
29396 
  Attributes:
29397 
   - rechargeOrderId
29398 
  """
29399 
 
29400 
  thrift_spec = (
29401 
    None, # 0
29402 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29403 
  )
29404 
 
29405 
  def __init__(self, rechargeOrderId=None,):
29406 
    self.rechargeOrderId = rechargeOrderId
29407 
 
29408 
  def read(self, iprot):
29409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29411 
      return
29412 
    iprot.readStructBegin()
29413 
    while True:
29414 
      (fname, ftype, fid) = iprot.readFieldBegin()
29415 
      if ftype == TType.STOP:
29416 
        break
29417 
      if fid == 1:
29418 
        if ftype == TType.I64:
29419 
          self.rechargeOrderId = iprot.readI64();
29420 
        else:
29421 
          iprot.skip(ftype)
29422 
      else:
29423 
        iprot.skip(ftype)
29424 
      iprot.readFieldEnd()
29425 
    iprot.readStructEnd()
29426 
 
29427 
  def write(self, oprot):
29428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29430 
      return
29431 
    oprot.writeStructBegin('refundRechargeOrder_args')
29432 
    if self.rechargeOrderId is not None:
29433 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29434 
      oprot.writeI64(self.rechargeOrderId)
29435 
      oprot.writeFieldEnd()
29436 
    oprot.writeFieldStop()
29437 
    oprot.writeStructEnd()
29438 
 
29439 
  def validate(self):
29440 
    return
29441 
 
29442 
 
29443 
  def __repr__(self):
29444 
    L = ['%s=%r' % (key, value)
29445 
      for key, value in self.__dict__.iteritems()]
29446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29447 
 
29448 
  def __eq__(self, other):
29449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29450 
 
29451 
  def __ne__(self, other):
29452 
    return not (self == other)
29453 
 
29454 
class refundRechargeOrder_result:
29455 
  """
29456 
  Attributes:
29457 
   - success
29458 
   - ex
29459 
  """
29460 
 
29461 
  thrift_spec = (
29462 
    (0, TType.BOOL, 'success', None, None, ), # 0
29463 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29464 
  )
29465 
 
29466 
  def __init__(self, success=None, ex=None,):
29467 
    self.success = success
29468 
    self.ex = ex
29469 
 
29470 
  def read(self, iprot):
29471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29473 
      return
29474 
    iprot.readStructBegin()
29475 
    while True:
29476 
      (fname, ftype, fid) = iprot.readFieldBegin()
29477 
      if ftype == TType.STOP:
29478 
        break
29479 
      if fid == 0:
29480 
        if ftype == TType.BOOL:
29481 
          self.success = iprot.readBool();
29482 
        else:
29483 
          iprot.skip(ftype)
29484 
      elif fid == 1:
29485 
        if ftype == TType.STRUCT:
29486 
          self.ex = TransactionServiceException()
29487 
          self.ex.read(iprot)
29488 
        else:
29489 
          iprot.skip(ftype)
29490 
      else:
29491 
        iprot.skip(ftype)
29492 
      iprot.readFieldEnd()
29493 
    iprot.readStructEnd()
29494 
 
29495 
  def write(self, oprot):
29496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29498 
      return
29499 
    oprot.writeStructBegin('refundRechargeOrder_result')
29500 
    if self.success is not None:
29501 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29502 
      oprot.writeBool(self.success)
29503 
      oprot.writeFieldEnd()
29504 
    if self.ex is not None:
29505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29506 
      self.ex.write(oprot)
29507 
      oprot.writeFieldEnd()
29508 
    oprot.writeFieldStop()
29509 
    oprot.writeStructEnd()
29510 
 
29511 
  def validate(self):
29512 
    return
29513 
 
29514 
 
29515 
  def __repr__(self):
29516 
    L = ['%s=%r' % (key, value)
29517 
      for key, value in self.__dict__.iteritems()]
29518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29519 
 
29520 
  def __eq__(self, other):
29521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29522 
 
29523 
  def __ne__(self, other):
29524 
    return not (self == other)
6821 amar.kumar 29525 
 
29526 
class getPhysicalOrders_args:
29527 
  """
29528 
  Attributes:
29529 
   - fromDate
29530 
   - toDate
29531 
  """
29532 
 
29533 
  thrift_spec = (
29534 
    None, # 0
29535 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29536 
    (2, TType.I64, 'toDate', None, None, ), # 2
29537 
  )
29538 
 
29539 
  def __init__(self, fromDate=None, toDate=None,):
29540 
    self.fromDate = fromDate
29541 
    self.toDate = toDate
29542 
 
29543 
  def read(self, iprot):
29544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29546 
      return
29547 
    iprot.readStructBegin()
29548 
    while True:
29549 
      (fname, ftype, fid) = iprot.readFieldBegin()
29550 
      if ftype == TType.STOP:
29551 
        break
29552 
      if fid == 1:
29553 
        if ftype == TType.I64:
29554 
          self.fromDate = iprot.readI64();
29555 
        else:
29556 
          iprot.skip(ftype)
29557 
      elif fid == 2:
29558 
        if ftype == TType.I64:
29559 
          self.toDate = iprot.readI64();
29560 
        else:
29561 
          iprot.skip(ftype)
29562 
      else:
29563 
        iprot.skip(ftype)
29564 
      iprot.readFieldEnd()
29565 
    iprot.readStructEnd()
29566 
 
29567 
  def write(self, oprot):
29568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29570 
      return
29571 
    oprot.writeStructBegin('getPhysicalOrders_args')
29572 
    if self.fromDate is not None:
29573 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29574 
      oprot.writeI64(self.fromDate)
29575 
      oprot.writeFieldEnd()
29576 
    if self.toDate is not None:
29577 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29578 
      oprot.writeI64(self.toDate)
29579 
      oprot.writeFieldEnd()
29580 
    oprot.writeFieldStop()
29581 
    oprot.writeStructEnd()
29582 
 
29583 
  def validate(self):
29584 
    return
29585 
 
29586 
 
29587 
  def __repr__(self):
29588 
    L = ['%s=%r' % (key, value)
29589 
      for key, value in self.__dict__.iteritems()]
29590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29591 
 
29592 
  def __eq__(self, other):
29593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29594 
 
29595 
  def __ne__(self, other):
29596 
    return not (self == other)
29597 
 
29598 
class getPhysicalOrders_result:
29599 
  """
29600 
  Attributes:
29601 
   - success
29602 
  """
29603 
 
29604 
  thrift_spec = (
29605 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29606 
  )
29607 
 
29608 
  def __init__(self, success=None,):
29609 
    self.success = success
29610 
 
29611 
  def read(self, iprot):
29612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29614 
      return
29615 
    iprot.readStructBegin()
29616 
    while True:
29617 
      (fname, ftype, fid) = iprot.readFieldBegin()
29618 
      if ftype == TType.STOP:
29619 
        break
29620 
      if fid == 0:
29621 
        if ftype == TType.LIST:
29622 
          self.success = []
29623 
          (_etype726, _size723) = iprot.readListBegin()
29624 
          for _i727 in xrange(_size723):
29625 
            _elem728 = Order()
29626 
            _elem728.read(iprot)
29627 
            self.success.append(_elem728)
29628 
          iprot.readListEnd()
29629 
        else:
29630 
          iprot.skip(ftype)
29631 
      else:
29632 
        iprot.skip(ftype)
29633 
      iprot.readFieldEnd()
29634 
    iprot.readStructEnd()
29635 
 
29636 
  def write(self, oprot):
29637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29639 
      return
29640 
    oprot.writeStructBegin('getPhysicalOrders_result')
29641 
    if self.success is not None:
29642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29643 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29644 
      for iter729 in self.success:
29645 
        iter729.write(oprot)
29646 
      oprot.writeListEnd()
29647 
      oprot.writeFieldEnd()
29648 
    oprot.writeFieldStop()
29649 
    oprot.writeStructEnd()
29650 
 
29651 
  def validate(self):
29652 
    return
29653 
 
29654 
 
29655 
  def __repr__(self):
29656 
    L = ['%s=%r' % (key, value)
29657 
      for key, value in self.__dict__.iteritems()]
29658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29659 
 
29660 
  def __eq__(self, other):
29661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29662 
 
29663 
  def __ne__(self, other):
29664 
    return not (self == other)