Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
525 
    Returns the final flag status.
526 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6050 anupam.sin 1340 
  def getRechargeOrdersForTransaction(self, txnId):
1341 
    """
1342 
    Returns a recharge order for a given transactionId
1343 
 
1344 
    Parameters:
1345 
     - txnId
1346 
    """
1347 
    pass
1348 
 
6048 rajveer 1349 
  def getServiceProviders(self, rechargeType):
1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
1353 
    """
1354 
    pass
6000 mandeep.dh 1355 
 
6049 rajveer 1356 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1357 
    """
1358 
    Parameters:
6049 rajveer 1359 
     - rechargeType
6048 rajveer 1360 
     - deviceNumber
1361 
    """
1362 
    pass
1363 
 
6094 rajveer 1364 
  def getRechargeOrdersForDevice(self, deviceNumber):
1365 
    """
1366 
    Parameters:
1367 
     - deviceNumber
1368 
    """
1369 
    pass
6048 rajveer 1370 
 
6094 rajveer 1371 
  def addAmountToWallet(self, userId, orderId, amount):
1372 
    """
1373 
    Parameters:
1374 
     - userId
1375 
     - orderId
1376 
     - amount
1377 
    """
1378 
    pass
1379 
 
1380 
 
3376 rajveer 1381 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1382 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1383 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1384 
 
1385 
  def createTransaction(self, transaction):
1386 
    """
1387 
    Parameters:
1388 
     - transaction
1389 
    """
1390 
    self.send_createTransaction(transaction)
132 ashish 1391 
    return self.recv_createTransaction()
94 ashish 1392 
 
1393 
  def send_createTransaction(self, transaction):
1394 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1395 
    args = createTransaction_args()
1396 
    args.transaction = transaction
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_createTransaction(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = createTransaction_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
3431 rajveer 1411 
    if result.success is not None:
132 ashish 1412 
      return result.success
3431 rajveer 1413 
    if result.ex is not None:
94 ashish 1414 
      raise result.ex
132 ashish 1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1416 
 
1417 
  def getTransaction(self, id):
1418 
    """
1419 
    Parameters:
1420 
     - id
1421 
    """
1422 
    self.send_getTransaction(id)
1423 
    return self.recv_getTransaction()
1424 
 
1425 
  def send_getTransaction(self, id):
1426 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1427 
    args = getTransaction_args()
1428 
    args.id = id
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getTransaction(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getTransaction_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
3431 rajveer 1443 
    if result.success is not None:
94 ashish 1444 
      return result.success
3431 rajveer 1445 
    if result.ex is not None:
94 ashish 1446 
      raise result.ex
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1448 
 
1449 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1450 
    """
1451 
    Parameters:
1452 
     - customerId
1453 
     - from_date
1454 
     - to_date
1455 
     - status
1456 
    """
1457 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1458 
    return self.recv_getTransactionsForCustomer()
1459 
 
1460 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1461 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1462 
    args = getTransactionsForCustomer_args()
1463 
    args.customerId = customerId
1464 
    args.from_date = from_date
1465 
    args.to_date = to_date
1466 
    args.status = status
1467 
    args.write(self._oprot)
1468 
    self._oprot.writeMessageEnd()
1469 
    self._oprot.trans.flush()
1470 
 
1471 
  def recv_getTransactionsForCustomer(self, ):
1472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1473 
    if mtype == TMessageType.EXCEPTION:
1474 
      x = TApplicationException()
1475 
      x.read(self._iprot)
1476 
      self._iprot.readMessageEnd()
1477 
      raise x
1478 
    result = getTransactionsForCustomer_result()
1479 
    result.read(self._iprot)
1480 
    self._iprot.readMessageEnd()
3431 rajveer 1481 
    if result.success is not None:
94 ashish 1482 
      return result.success
3431 rajveer 1483 
    if result.ex is not None:
94 ashish 1484 
      raise result.ex
1485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1486 
 
132 ashish 1487 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1488 
    """
1489 
    Parameters:
1490 
     - shoppingCartId
1491 
    """
1492 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1493 
    return self.recv_getTransactionsForShoppingCartId()
1494 
 
1495 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1496 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1497 
    args = getTransactionsForShoppingCartId_args()
1498 
    args.shoppingCartId = shoppingCartId
1499 
    args.write(self._oprot)
1500 
    self._oprot.writeMessageEnd()
1501 
    self._oprot.trans.flush()
1502 
 
1503 
  def recv_getTransactionsForShoppingCartId(self, ):
1504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1505 
    if mtype == TMessageType.EXCEPTION:
1506 
      x = TApplicationException()
1507 
      x.read(self._iprot)
1508 
      self._iprot.readMessageEnd()
1509 
      raise x
1510 
    result = getTransactionsForShoppingCartId_result()
1511 
    result.read(self._iprot)
1512 
    self._iprot.readMessageEnd()
3431 rajveer 1513 
    if result.success is not None:
132 ashish 1514 
      return result.success
3431 rajveer 1515 
    if result.ex is not None:
132 ashish 1516 
      raise result.ex
1517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1518 
 
94 ashish 1519 
  def getTransactionStatus(self, transactionId):
1520 
    """
1521 
    Parameters:
1522 
     - transactionId
1523 
    """
1524 
    self.send_getTransactionStatus(transactionId)
1525 
    return self.recv_getTransactionStatus()
1526 
 
1527 
  def send_getTransactionStatus(self, transactionId):
1528 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1529 
    args = getTransactionStatus_args()
1530 
    args.transactionId = transactionId
1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_getTransactionStatus(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = getTransactionStatus_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
3431 rajveer 1545 
    if result.success is not None:
94 ashish 1546 
      return result.success
3431 rajveer 1547 
    if result.ex is not None:
94 ashish 1548 
      raise result.ex
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1550 
 
5527 anupam.sin 1551 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1552 
    """
1553 
    Parameters:
1554 
     - transactionId
1555 
     - status
1556 
     - description
5527 anupam.sin 1557 
     - pickUp
1558 
     - orderType
94 ashish 1559 
    """
5527 anupam.sin 1560 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1561 
    return self.recv_changeTransactionStatus()
1562 
 
5527 anupam.sin 1563 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1564 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1565 
    args = changeTransactionStatus_args()
1566 
    args.transactionId = transactionId
1567 
    args.status = status
1568 
    args.description = description
5527 anupam.sin 1569 
    args.pickUp = pickUp
1570 
    args.orderType = orderType
94 ashish 1571 
    args.write(self._oprot)
1572 
    self._oprot.writeMessageEnd()
1573 
    self._oprot.trans.flush()
1574 
 
1575 
  def recv_changeTransactionStatus(self, ):
1576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1577 
    if mtype == TMessageType.EXCEPTION:
1578 
      x = TApplicationException()
1579 
      x.read(self._iprot)
1580 
      self._iprot.readMessageEnd()
1581 
      raise x
1582 
    result = changeTransactionStatus_result()
1583 
    result.read(self._iprot)
1584 
    self._iprot.readMessageEnd()
3431 rajveer 1585 
    if result.success is not None:
94 ashish 1586 
      return result.success
3431 rajveer 1587 
    if result.ex is not None:
94 ashish 1588 
      raise result.ex
1589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1590 
 
1398 varun.gupt 1591 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1592 
    """
1593 
    Parameters:
1594 
     - transactionId
1595 
    """
1398 varun.gupt 1596 
    self.send_enqueueTransactionInfoEmail(transactionId)
1597 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1598 
 
1398 varun.gupt 1599 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1600 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1601 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1602 
    args.transactionId = transactionId
1603 
    args.write(self._oprot)
1604 
    self._oprot.writeMessageEnd()
1605 
    self._oprot.trans.flush()
1606 
 
1398 varun.gupt 1607 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1609 
    if mtype == TMessageType.EXCEPTION:
1610 
      x = TApplicationException()
1611 
      x.read(self._iprot)
1612 
      self._iprot.readMessageEnd()
1613 
      raise x
1398 varun.gupt 1614 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1615 
    result.read(self._iprot)
1616 
    self._iprot.readMessageEnd()
3431 rajveer 1617 
    if result.success is not None:
1382 varun.gupt 1618 
      return result.success
3431 rajveer 1619 
    if result.ex is not None:
1382 varun.gupt 1620 
      raise result.ex
1398 varun.gupt 1621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1622 
 
4801 anupam.sin 1623 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1624 
    """
1625 
    Parameters:
4801 anupam.sin 1626 
     - statuses
483 rajveer 1627 
     - from_date
1628 
     - to_date
1629 
     - warehouse_id
94 ashish 1630 
    """
4801 anupam.sin 1631 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1632 
    return self.recv_getAllOrders()
94 ashish 1633 
 
4801 anupam.sin 1634 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1635 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1636 
    args = getAllOrders_args()
4801 anupam.sin 1637 
    args.statuses = statuses
483 rajveer 1638 
    args.from_date = from_date
1639 
    args.to_date = to_date
1640 
    args.warehouse_id = warehouse_id
94 ashish 1641 
    args.write(self._oprot)
1642 
    self._oprot.writeMessageEnd()
1643 
    self._oprot.trans.flush()
1644 
 
483 rajveer 1645 
  def recv_getAllOrders(self, ):
94 ashish 1646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1647 
    if mtype == TMessageType.EXCEPTION:
1648 
      x = TApplicationException()
1649 
      x.read(self._iprot)
1650 
      self._iprot.readMessageEnd()
1651 
      raise x
483 rajveer 1652 
    result = getAllOrders_result()
94 ashish 1653 
    result.read(self._iprot)
1654 
    self._iprot.readMessageEnd()
3431 rajveer 1655 
    if result.success is not None:
94 ashish 1656 
      return result.success
3431 rajveer 1657 
    if result.ex is not None:
94 ashish 1658 
      raise result.ex
483 rajveer 1659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1660 
 
4133 chandransh 1661 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1662 
    """
1663 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1664 
    Pass the status as null and the limit as 0 to ignore them.
1665 
 
1666 
    Parameters:
1667 
     - statuses
1668 
     - offset
1669 
     - limit
1670 
     - warehouse_id
1671 
    """
1672 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1673 
    return self.recv_getOrdersInBatch()
1674 
 
1675 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1676 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1677 
    args = getOrdersInBatch_args()
1678 
    args.statuses = statuses
1679 
    args.offset = offset
1680 
    args.limit = limit
1681 
    args.warehouse_id = warehouse_id
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_getOrdersInBatch(self, ):
1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
1693 
    result = getOrdersInBatch_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
1696 
    if result.success is not None:
1697 
      return result.success
1698 
    if result.ex is not None:
1699 
      raise result.ex
1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1701 
 
1702 
  def getOrderCount(self, statuses, warehouseId):
1703 
    """
1704 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1705 
 
1706 
    Parameters:
1707 
     - statuses
1708 
     - warehouseId
1709 
    """
1710 
    self.send_getOrderCount(statuses, warehouseId)
1711 
    return self.recv_getOrderCount()
1712 
 
1713 
  def send_getOrderCount(self, statuses, warehouseId):
1714 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1715 
    args = getOrderCount_args()
1716 
    args.statuses = statuses
1717 
    args.warehouseId = warehouseId
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_getOrderCount(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = getOrderCount_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
1732 
    if result.success is not None:
1733 
      return result.success
1734 
    if result.ex is not None:
1735 
      raise result.ex
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1737 
 
999 varun.gupt 1738 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1739 
    """
1132 chandransh 1740 
    Returns orders within a range of their billing dates
3431 rajveer 1741 
 
999 varun.gupt 1742 
    Parameters:
1743 
     - status
1744 
     - start_billing_date
1745 
     - end_billing_date
1746 
     - warehouse_id
1747 
    """
1748 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1749 
    return self.recv_getOrdersByBillingDate()
1750 
 
1751 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1752 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1753 
    args = getOrdersByBillingDate_args()
1754 
    args.status = status
1755 
    args.start_billing_date = start_billing_date
1756 
    args.end_billing_date = end_billing_date
1757 
    args.warehouse_id = warehouse_id
1758 
    args.write(self._oprot)
1759 
    self._oprot.writeMessageEnd()
1760 
    self._oprot.trans.flush()
1761 
 
1762 
  def recv_getOrdersByBillingDate(self, ):
1763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1764 
    if mtype == TMessageType.EXCEPTION:
1765 
      x = TApplicationException()
1766 
      x.read(self._iprot)
1767 
      self._iprot.readMessageEnd()
1768 
      raise x
1769 
    result = getOrdersByBillingDate_result()
1770 
    result.read(self._iprot)
1771 
    self._iprot.readMessageEnd()
3431 rajveer 1772 
    if result.success is not None:
999 varun.gupt 1773 
      return result.success
3431 rajveer 1774 
    if result.ex is not None:
999 varun.gupt 1775 
      raise result.ex
1776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1777 
 
3451 chandransh 1778 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1779 
    """
1780 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1781 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1782 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1783 
 
3427 chandransh 1784 
    Parameters:
1785 
     - fromShippingDate
1786 
     - toShippingDate
1787 
     - providerId
1788 
     - warehouseId
3451 chandransh 1789 
     - cod
3427 chandransh 1790 
    """
3451 chandransh 1791 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1792 
    return self.recv_getOrdersByShippingDate()
1793 
 
3451 chandransh 1794 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1795 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1796 
    args = getOrdersByShippingDate_args()
1797 
    args.fromShippingDate = fromShippingDate
1798 
    args.toShippingDate = toShippingDate
1799 
    args.providerId = providerId
1800 
    args.warehouseId = warehouseId
3451 chandransh 1801 
    args.cod = cod
3427 chandransh 1802 
    args.write(self._oprot)
1803 
    self._oprot.writeMessageEnd()
1804 
    self._oprot.trans.flush()
1805 
 
1806 
  def recv_getOrdersByShippingDate(self, ):
1807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1808 
    if mtype == TMessageType.EXCEPTION:
1809 
      x = TApplicationException()
1810 
      x.read(self._iprot)
1811 
      self._iprot.readMessageEnd()
1812 
      raise x
1813 
    result = getOrdersByShippingDate_result()
1814 
    result.read(self._iprot)
1815 
    self._iprot.readMessageEnd()
3431 rajveer 1816 
    if result.success is not None:
3427 chandransh 1817 
      return result.success
3431 rajveer 1818 
    if result.ex is not None:
3427 chandransh 1819 
      raise result.ex
1820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1821 
 
1382 varun.gupt 1822 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1823 
    """
1824 
    Returns order ids for orders which can be returned
3431 rajveer 1825 
 
1382 varun.gupt 1826 
    Parameters:
1827 
     - customer_id
1828 
     - limit
1829 
    """
1830 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1831 
    return self.recv_getReturnableOrdersForCustomer()
1832 
 
1833 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1834 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1835 
    args = getReturnableOrdersForCustomer_args()
1836 
    args.customer_id = customer_id
1837 
    args.limit = limit
1838 
    args.write(self._oprot)
1839 
    self._oprot.writeMessageEnd()
1840 
    self._oprot.trans.flush()
1841 
 
1842 
  def recv_getReturnableOrdersForCustomer(self, ):
1843 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1844 
    if mtype == TMessageType.EXCEPTION:
1845 
      x = TApplicationException()
1846 
      x.read(self._iprot)
1847 
      self._iprot.readMessageEnd()
1848 
      raise x
1849 
    result = getReturnableOrdersForCustomer_result()
1850 
    result.read(self._iprot)
1851 
    self._iprot.readMessageEnd()
3431 rajveer 1852 
    if result.success is not None:
1382 varun.gupt 1853 
      return result.success
3431 rajveer 1854 
    if result.ex is not None:
1382 varun.gupt 1855 
      raise result.ex
1856 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1857 
 
1858 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1859 
    """
1860 
    Returns order ids for orders which can be cancelled
3431 rajveer 1861 
 
1382 varun.gupt 1862 
    Parameters:
1863 
     - customer_id
1864 
     - limit
1865 
    """
1866 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1867 
    return self.recv_getCancellableOrdersForCustomer()
1868 
 
1869 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1870 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1871 
    args = getCancellableOrdersForCustomer_args()
1872 
    args.customer_id = customer_id
1873 
    args.limit = limit
1874 
    args.write(self._oprot)
1875 
    self._oprot.writeMessageEnd()
1876 
    self._oprot.trans.flush()
1877 
 
1878 
  def recv_getCancellableOrdersForCustomer(self, ):
1879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1880 
    if mtype == TMessageType.EXCEPTION:
1881 
      x = TApplicationException()
1882 
      x.read(self._iprot)
1883 
      self._iprot.readMessageEnd()
1884 
      raise x
1885 
    result = getCancellableOrdersForCustomer_result()
1886 
    result.read(self._iprot)
1887 
    self._iprot.readMessageEnd()
3431 rajveer 1888 
    if result.success is not None:
1382 varun.gupt 1889 
      return result.success
3431 rajveer 1890 
    if result.ex is not None:
1382 varun.gupt 1891 
      raise result.ex
1892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1893 
 
483 rajveer 1894 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1895 
    """
1896 
    Parameters:
483 rajveer 1897 
     - orderId
1898 
     - status
1899 
     - description
94 ashish 1900 
    """
483 rajveer 1901 
    self.send_changeOrderStatus(orderId, status, description)
1902 
    return self.recv_changeOrderStatus()
94 ashish 1903 
 
483 rajveer 1904 
  def send_changeOrderStatus(self, orderId, status, description):
1905 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1906 
    args = changeOrderStatus_args()
1907 
    args.orderId = orderId
1908 
    args.status = status
1909 
    args.description = description
94 ashish 1910 
    args.write(self._oprot)
1911 
    self._oprot.writeMessageEnd()
1912 
    self._oprot.trans.flush()
1913 
 
483 rajveer 1914 
  def recv_changeOrderStatus(self, ):
94 ashish 1915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1916 
    if mtype == TMessageType.EXCEPTION:
1917 
      x = TApplicationException()
1918 
      x.read(self._iprot)
1919 
      self._iprot.readMessageEnd()
1920 
      raise x
483 rajveer 1921 
    result = changeOrderStatus_result()
94 ashish 1922 
    result.read(self._iprot)
1923 
    self._iprot.readMessageEnd()
3431 rajveer 1924 
    if result.success is not None:
94 ashish 1925 
      return result.success
3431 rajveer 1926 
    if result.ex is not None:
94 ashish 1927 
      raise result.ex
483 rajveer 1928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1929 
 
1528 ankur.sing 1930 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1931 
    """
1528 ankur.sing 1932 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1933 
    only user who owns the transaction can view its order details.
3431 rajveer 1934 
 
94 ashish 1935 
    Parameters:
1936 
     - transactionId
1528 ankur.sing 1937 
     - customerId
94 ashish 1938 
    """
1528 ankur.sing 1939 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1940 
    return self.recv_getOrdersForTransaction()
94 ashish 1941 
 
1528 ankur.sing 1942 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1943 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1944 
    args = getOrdersForTransaction_args()
94 ashish 1945 
    args.transactionId = transactionId
1528 ankur.sing 1946 
    args.customerId = customerId
94 ashish 1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
483 rajveer 1951 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
483 rajveer 1958 
    result = getOrdersForTransaction_result()
94 ashish 1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
3431 rajveer 1961 
    if result.success is not None:
94 ashish 1962 
      return result.success
3431 rajveer 1963 
    if result.ex is not None:
94 ashish 1964 
      raise result.ex
483 rajveer 1965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1966 
 
3014 chandransh 1967 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 1968 
    """
3014 chandransh 1969 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
1970 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 1971 
 
94 ashish 1972 
    Parameters:
483 rajveer 1973 
     - customerId
1974 
     - from_date
1975 
     - to_date
3014 chandransh 1976 
     - statuses
94 ashish 1977 
    """
3014 chandransh 1978 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 1979 
    return self.recv_getOrdersForCustomer()
94 ashish 1980 
 
3014 chandransh 1981 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 1982 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1983 
    args = getOrdersForCustomer_args()
1984 
    args.customerId = customerId
1985 
    args.from_date = from_date
1986 
    args.to_date = to_date
3014 chandransh 1987 
    args.statuses = statuses
94 ashish 1988 
    args.write(self._oprot)
1989 
    self._oprot.writeMessageEnd()
1990 
    self._oprot.trans.flush()
1991 
 
483 rajveer 1992 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1994 
    if mtype == TMessageType.EXCEPTION:
1995 
      x = TApplicationException()
1996 
      x.read(self._iprot)
1997 
      self._iprot.readMessageEnd()
1998 
      raise x
483 rajveer 1999 
    result = getOrdersForCustomer_result()
94 ashish 2000 
    result.read(self._iprot)
2001 
    self._iprot.readMessageEnd()
3431 rajveer 2002 
    if result.success is not None:
94 ashish 2003 
      return result.success
3431 rajveer 2004 
    if result.ex is not None:
94 ashish 2005 
      raise result.ex
483 rajveer 2006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2007 
 
483 rajveer 2008 
  def createOrder(self, order):
94 ashish 2009 
    """
2010 
    Parameters:
483 rajveer 2011 
     - order
94 ashish 2012 
    """
483 rajveer 2013 
    self.send_createOrder(order)
2014 
    return self.recv_createOrder()
94 ashish 2015 
 
483 rajveer 2016 
  def send_createOrder(self, order):
2017 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2018 
    args = createOrder_args()
2019 
    args.order = order
94 ashish 2020 
    args.write(self._oprot)
2021 
    self._oprot.writeMessageEnd()
2022 
    self._oprot.trans.flush()
2023 
 
483 rajveer 2024 
  def recv_createOrder(self, ):
94 ashish 2025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2026 
    if mtype == TMessageType.EXCEPTION:
2027 
      x = TApplicationException()
2028 
      x.read(self._iprot)
2029 
      self._iprot.readMessageEnd()
2030 
      raise x
483 rajveer 2031 
    result = createOrder_result()
94 ashish 2032 
    result.read(self._iprot)
2033 
    self._iprot.readMessageEnd()
3431 rajveer 2034 
    if result.success is not None:
94 ashish 2035 
      return result.success
3431 rajveer 2036 
    if result.ex is not None:
94 ashish 2037 
      raise result.ex
483 rajveer 2038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2039 
 
483 rajveer 2040 
  def getOrder(self, id):
94 ashish 2041 
    """
2042 
    Parameters:
483 rajveer 2043 
     - id
94 ashish 2044 
    """
483 rajveer 2045 
    self.send_getOrder(id)
2046 
    return self.recv_getOrder()
94 ashish 2047 
 
483 rajveer 2048 
  def send_getOrder(self, id):
2049 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2050 
    args = getOrder_args()
2051 
    args.id = id
94 ashish 2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
483 rajveer 2056 
  def recv_getOrder(self, ):
94 ashish 2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
483 rajveer 2063 
    result = getOrder_result()
94 ashish 2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
3431 rajveer 2066 
    if result.success is not None:
94 ashish 2067 
      return result.success
3431 rajveer 2068 
    if result.ex is not None:
94 ashish 2069 
      raise result.ex
483 rajveer 2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2071 
 
483 rajveer 2072 
  def getLineItemsForOrder(self, orderId):
94 ashish 2073 
    """
2074 
    Parameters:
483 rajveer 2075 
     - orderId
94 ashish 2076 
    """
483 rajveer 2077 
    self.send_getLineItemsForOrder(orderId)
2078 
    return self.recv_getLineItemsForOrder()
94 ashish 2079 
 
483 rajveer 2080 
  def send_getLineItemsForOrder(self, orderId):
2081 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2082 
    args = getLineItemsForOrder_args()
2083 
    args.orderId = orderId
94 ashish 2084 
    args.write(self._oprot)
2085 
    self._oprot.writeMessageEnd()
2086 
    self._oprot.trans.flush()
2087 
 
483 rajveer 2088 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2090 
    if mtype == TMessageType.EXCEPTION:
2091 
      x = TApplicationException()
2092 
      x.read(self._iprot)
2093 
      self._iprot.readMessageEnd()
2094 
      raise x
483 rajveer 2095 
    result = getLineItemsForOrder_result()
94 ashish 2096 
    result.read(self._iprot)
2097 
    self._iprot.readMessageEnd()
3431 rajveer 2098 
    if result.success is not None:
94 ashish 2099 
      return result.success
3431 rajveer 2100 
    if result.ex is not None:
94 ashish 2101 
      raise result.ex
483 rajveer 2102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2103 
 
4999 phani.kuma 2104 
  def getOrderList(self, order_ids):
2105 
    """
2106 
    Parameters:
2107 
     - order_ids
2108 
    """
2109 
    self.send_getOrderList(order_ids)
2110 
    return self.recv_getOrderList()
2111 
 
2112 
  def send_getOrderList(self, order_ids):
2113 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2114 
    args = getOrderList_args()
2115 
    args.order_ids = order_ids
2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
2120 
  def recv_getOrderList(self, ):
2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
2127 
    result = getOrderList_result()
2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
2130 
    if result.success is not None:
2131 
      return result.success
2132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2133 
 
5386 phani.kuma 2134 
  def getOrderListForVendor(self, order_ids, vendorId):
2135 
    """
2136 
    Parameters:
2137 
     - order_ids
2138 
     - vendorId
2139 
    """
2140 
    self.send_getOrderListForVendor(order_ids, vendorId)
2141 
    return self.recv_getOrderListForVendor()
2142 
 
2143 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2144 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2145 
    args = getOrderListForVendor_args()
2146 
    args.order_ids = order_ids
2147 
    args.vendorId = vendorId
2148 
    args.write(self._oprot)
2149 
    self._oprot.writeMessageEnd()
2150 
    self._oprot.trans.flush()
2151 
 
2152 
  def recv_getOrderListForVendor(self, ):
2153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2154 
    if mtype == TMessageType.EXCEPTION:
2155 
      x = TApplicationException()
2156 
      x.read(self._iprot)
2157 
      self._iprot.readMessageEnd()
2158 
      raise x
2159 
    result = getOrderListForVendor_result()
2160 
    result.read(self._iprot)
2161 
    self._iprot.readMessageEnd()
2162 
    if result.success is not None:
2163 
      return result.success
2164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2165 
 
1528 ankur.sing 2166 
  def getOrderForCustomer(self, orderId, customerId):
2167 
    """
2168 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2169 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2170 
 
1528 ankur.sing 2171 
    Parameters:
2172 
     - orderId
2173 
     - customerId
2174 
    """
2175 
    self.send_getOrderForCustomer(orderId, customerId)
2176 
    return self.recv_getOrderForCustomer()
2177 
 
2178 
  def send_getOrderForCustomer(self, orderId, customerId):
2179 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2180 
    args = getOrderForCustomer_args()
2181 
    args.orderId = orderId
2182 
    args.customerId = customerId
2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
2187 
  def recv_getOrderForCustomer(self, ):
2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
2194 
    result = getOrderForCustomer_result()
2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
3431 rajveer 2197 
    if result.success is not None:
1528 ankur.sing 2198 
      return result.success
3431 rajveer 2199 
    if result.ex is not None:
1528 ankur.sing 2200 
      raise result.ex
2201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2202 
 
4444 rajveer 2203 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2204 
    """
2205 
    Parameters:
4394 rajveer 2206 
     - type
4444 rajveer 2207 
     - warehouseId
4394 rajveer 2208 
     - status
2209 
     - timestamp
3064 chandransh 2210 
    """
4444 rajveer 2211 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2212 
    return self.recv_getAlerts()
2213 
 
4444 rajveer 2214 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2215 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2216 
    args = getAlerts_args()
4394 rajveer 2217 
    args.type = type
4444 rajveer 2218 
    args.warehouseId = warehouseId
4394 rajveer 2219 
    args.status = status
2220 
    args.timestamp = timestamp
3064 chandransh 2221 
    args.write(self._oprot)
2222 
    self._oprot.writeMessageEnd()
2223 
    self._oprot.trans.flush()
2224 
 
2225 
  def recv_getAlerts(self, ):
2226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2227 
    if mtype == TMessageType.EXCEPTION:
2228 
      x = TApplicationException()
2229 
      x.read(self._iprot)
2230 
      self._iprot.readMessageEnd()
2231 
      raise x
2232 
    result = getAlerts_result()
2233 
    result.read(self._iprot)
2234 
    self._iprot.readMessageEnd()
3431 rajveer 2235 
    if result.success is not None:
3064 chandransh 2236 
      return result.success
2237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2238 
 
4444 rajveer 2239 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2240 
    """
2241 
    Parameters:
2242 
     - type
4444 rajveer 2243 
     - warehouseId
4394 rajveer 2244 
     - description
3064 chandransh 2245 
    """
4444 rajveer 2246 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2247 
    self.recv_addAlert()
3064 chandransh 2248 
 
4444 rajveer 2249 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2250 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2251 
    args = addAlert_args()
3064 chandransh 2252 
    args.type = type
4444 rajveer 2253 
    args.warehouseId = warehouseId
4394 rajveer 2254 
    args.description = description
3064 chandransh 2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
4394 rajveer 2259 
  def recv_addAlert(self, ):
3064 chandransh 2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
4394 rajveer 2266 
    result = addAlert_result()
3064 chandransh 2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
2269 
    return
2270 
 
4444 rajveer 2271 
  def markAlertsAsSeen(self, warehouseId):
2272 
    """
2273 
    Parameters:
2274 
     - warehouseId
2275 
    """
2276 
    self.send_markAlertsAsSeen(warehouseId)
2277 
    self.recv_markAlertsAsSeen()
2278 
 
2279 
  def send_markAlertsAsSeen(self, warehouseId):
2280 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2281 
    args = markAlertsAsSeen_args()
2282 
    args.warehouseId = warehouseId
2283 
    args.write(self._oprot)
2284 
    self._oprot.writeMessageEnd()
2285 
    self._oprot.trans.flush()
2286 
 
2287 
  def recv_markAlertsAsSeen(self, ):
2288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2289 
    if mtype == TMessageType.EXCEPTION:
2290 
      x = TApplicationException()
2291 
      x.read(self._iprot)
2292 
      self._iprot.readMessageEnd()
2293 
      raise x
2294 
    result = markAlertsAsSeen_result()
2295 
    result.read(self._iprot)
2296 
    self._iprot.readMessageEnd()
2297 
    return
2298 
 
3064 chandransh 2299 
  def getValidOrderCount(self, ):
2300 
    """
2301 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2302 
    """
2303 
    self.send_getValidOrderCount()
2304 
    return self.recv_getValidOrderCount()
2305 
 
2306 
  def send_getValidOrderCount(self, ):
2307 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2308 
    args = getValidOrderCount_args()
2309 
    args.write(self._oprot)
2310 
    self._oprot.writeMessageEnd()
2311 
    self._oprot.trans.flush()
2312 
 
2313 
  def recv_getValidOrderCount(self, ):
2314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2315 
    if mtype == TMessageType.EXCEPTION:
2316 
      x = TApplicationException()
2317 
      x.read(self._iprot)
2318 
      self._iprot.readMessageEnd()
2319 
      raise x
2320 
    result = getValidOrderCount_result()
2321 
    result.read(self._iprot)
2322 
    self._iprot.readMessageEnd()
3431 rajveer 2323 
    if result.success is not None:
3064 chandransh 2324 
      return result.success
2325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2326 
 
2327 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2328 
    """
2329 
    Returns the number of distinct customers who have done successful transactions
2330 
    """
2331 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2332 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2333 
 
2334 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2335 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2336 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2337 
    args.write(self._oprot)
2338 
    self._oprot.writeMessageEnd()
2339 
    self._oprot.trans.flush()
2340 
 
2341 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2343 
    if mtype == TMessageType.EXCEPTION:
2344 
      x = TApplicationException()
2345 
      x.read(self._iprot)
2346 
      self._iprot.readMessageEnd()
2347 
      raise x
2348 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2349 
    result.read(self._iprot)
2350 
    self._iprot.readMessageEnd()
3431 rajveer 2351 
    if result.success is not None:
3064 chandransh 2352 
      return result.success
2353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2354 
 
2355 
  def getValidOrdersAmountRange(self, ):
2356 
    """
2357 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2358 
    List contains two values, first minimum amount and second maximum amount.
2359 
    """
2360 
    self.send_getValidOrdersAmountRange()
2361 
    return self.recv_getValidOrdersAmountRange()
2362 
 
2363 
  def send_getValidOrdersAmountRange(self, ):
2364 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2365 
    args = getValidOrdersAmountRange_args()
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_getValidOrdersAmountRange(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = getValidOrdersAmountRange_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
3431 rajveer 2380 
    if result.success is not None:
3064 chandransh 2381 
      return result.success
2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2383 
 
5874 rajveer 2384 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2385 
    """
2386 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2387 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2388 
 
3064 chandransh 2389 
    Parameters:
2390 
     - limit
5874 rajveer 2391 
     - onlyStore
3064 chandransh 2392 
    """
5874 rajveer 2393 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2394 
    return self.recv_getValidOrders()
2395 
 
5874 rajveer 2396 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2397 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2398 
    args = getValidOrders_args()
2399 
    args.limit = limit
5874 rajveer 2400 
    args.onlyStore = onlyStore
3064 chandransh 2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
2405 
  def recv_getValidOrders(self, ):
2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
2412 
    result = getValidOrders_result()
2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
3431 rajveer 2415 
    if result.success is not None:
3064 chandransh 2416 
      return result.success
2417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2418 
 
1220 chandransh 2419 
  def batchOrders(self, warehouseId):
2420 
    """
2421 
    Create a batch of all the pending orders for the given warehouse.
2422 
    The returned list is orderd by created_timestamp.
2423 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2424 
 
1220 chandransh 2425 
    Parameters:
2426 
     - warehouseId
2427 
    """
2428 
    self.send_batchOrders(warehouseId)
2429 
    return self.recv_batchOrders()
2430 
 
2431 
  def send_batchOrders(self, warehouseId):
2432 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2433 
    args = batchOrders_args()
2434 
    args.warehouseId = warehouseId
2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
2439 
  def recv_batchOrders(self, ):
2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
2446 
    result = batchOrders_result()
2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
3431 rajveer 2449 
    if result.success is not None:
1220 chandransh 2450 
      return result.success
3431 rajveer 2451 
    if result.ex is not None:
1220 chandransh 2452 
      raise result.ex
2453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2454 
 
1208 chandransh 2455 
  def markOrderAsOutOfStock(self, orderId):
2456 
    """
2457 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2458 
 
1208 chandransh 2459 
    Parameters:
2460 
     - orderId
2461 
    """
2462 
    self.send_markOrderAsOutOfStock(orderId)
2463 
    return self.recv_markOrderAsOutOfStock()
2464 
 
2465 
  def send_markOrderAsOutOfStock(self, orderId):
2466 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2467 
    args = markOrderAsOutOfStock_args()
2468 
    args.orderId = orderId
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
2473 
  def recv_markOrderAsOutOfStock(self, ):
2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
2480 
    result = markOrderAsOutOfStock_result()
2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
3431 rajveer 2483 
    if result.success is not None:
1208 chandransh 2484 
      return result.success
3431 rajveer 2485 
    if result.ex is not None:
1208 chandransh 2486 
      raise result.ex
2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2488 
 
3064 chandransh 2489 
  def verifyOrder(self, orderId):
759 chandransh 2490 
    """
3064 chandransh 2491 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2492 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2493 
    used for all other orders as well.
2494 
    Throws an exception if no such order exists.
3431 rajveer 2495 
 
759 chandransh 2496 
    Parameters:
3064 chandransh 2497 
     - orderId
759 chandransh 2498 
    """
3064 chandransh 2499 
    self.send_verifyOrder(orderId)
2500 
    return self.recv_verifyOrder()
759 chandransh 2501 
 
3064 chandransh 2502 
  def send_verifyOrder(self, orderId):
2503 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2504 
    args = verifyOrder_args()
2505 
    args.orderId = orderId
759 chandransh 2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
3064 chandransh 2510 
  def recv_verifyOrder(self, ):
759 chandransh 2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
3064 chandransh 2517 
    result = verifyOrder_result()
759 chandransh 2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
3431 rajveer 2520 
    if result.success is not None:
759 chandransh 2521 
      return result.success
3431 rajveer 2522 
    if result.ex is not None:
759 chandransh 2523 
      raise result.ex
3064 chandransh 2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2525 
 
3064 chandransh 2526 
  def acceptOrder(self, orderId):
1113 chandransh 2527 
    """
3064 chandransh 2528 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2529 
    given order is not a COD order, it also captures the payment if the same has
2530 
    not been captured.
2531 
    Throws an exception if no such order exists.
3431 rajveer 2532 
 
1113 chandransh 2533 
    Parameters:
3064 chandransh 2534 
     - orderId
1113 chandransh 2535 
    """
3064 chandransh 2536 
    self.send_acceptOrder(orderId)
2537 
    return self.recv_acceptOrder()
1113 chandransh 2538 
 
3064 chandransh 2539 
  def send_acceptOrder(self, orderId):
2540 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2541 
    args = acceptOrder_args()
2542 
    args.orderId = orderId
1113 chandransh 2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
3064 chandransh 2547 
  def recv_acceptOrder(self, ):
1113 chandransh 2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
3064 chandransh 2554 
    result = acceptOrder_result()
1113 chandransh 2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
3431 rajveer 2557 
    if result.success is not None:
1113 chandransh 2558 
      return result.success
3431 rajveer 2559 
    if result.ex is not None:
1113 chandransh 2560 
      raise result.ex
3064 chandransh 2561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2562 
 
5110 mandeep.dh 2563 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2564 
    """
3064 chandransh 2565 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2566 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2567 
    the IMEI no. if a -1 is supplied.
2568 
    Also, it generates an invoice number for the order, marks the order as
2569 
    BILLED and sets the billing timestamp.
2570 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2571 
 
1135 chandransh 2572 
    Parameters:
3064 chandransh 2573 
     - orderId
2574 
     - invoice_number
4658 mandeep.dh 2575 
     - serialNumber
4283 anupam.sin 2576 
     - itemNumber
3064 chandransh 2577 
     - billed_by
4264 rajveer 2578 
     - jacketNumber
4283 anupam.sin 2579 
     - billingType
5110 mandeep.dh 2580 
     - fulfilmentWarehouseId
4763 rajveer 2581 
     - authorize
1135 chandransh 2582 
    """
5110 mandeep.dh 2583 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2584 
    return self.recv_addBillingDetails()
1135 chandransh 2585 
 
5110 mandeep.dh 2586 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2587 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2588 
    args = addBillingDetails_args()
2589 
    args.orderId = orderId
2590 
    args.invoice_number = invoice_number
4658 mandeep.dh 2591 
    args.serialNumber = serialNumber
4283 anupam.sin 2592 
    args.itemNumber = itemNumber
3064 chandransh 2593 
    args.billed_by = billed_by
4264 rajveer 2594 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2595 
    args.billingType = billingType
5110 mandeep.dh 2596 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2597 
    args.authorize = authorize
1135 chandransh 2598 
    args.write(self._oprot)
2599 
    self._oprot.writeMessageEnd()
2600 
    self._oprot.trans.flush()
2601 
 
3064 chandransh 2602 
  def recv_addBillingDetails(self, ):
1135 chandransh 2603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2604 
    if mtype == TMessageType.EXCEPTION:
2605 
      x = TApplicationException()
2606 
      x.read(self._iprot)
2607 
      self._iprot.readMessageEnd()
2608 
      raise x
3064 chandransh 2609 
    result = addBillingDetails_result()
1135 chandransh 2610 
    result.read(self._iprot)
2611 
    self._iprot.readMessageEnd()
3431 rajveer 2612 
    if result.success is not None:
3064 chandransh 2613 
      return result.success
3431 rajveer 2614 
    if result.ex is not None:
1135 chandransh 2615 
      raise result.ex
3064 chandransh 2616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2617 
 
4763 rajveer 2618 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2619 
    """
2620 
    Add the invoice number to the order.
2621 
 
2622 
    Parameters:
2623 
     - orderId
2624 
     - invoiceNumber
4763 rajveer 2625 
     - color
4579 rajveer 2626 
    """
4763 rajveer 2627 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2628 
    self.recv_addInvoiceNumber()
2629 
 
4763 rajveer 2630 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2631 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2632 
    args = addInvoiceNumber_args()
2633 
    args.orderId = orderId
2634 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2635 
    args.color = color
4579 rajveer 2636 
    args.write(self._oprot)
2637 
    self._oprot.writeMessageEnd()
2638 
    self._oprot.trans.flush()
2639 
 
2640 
  def recv_addInvoiceNumber(self, ):
2641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2642 
    if mtype == TMessageType.EXCEPTION:
2643 
      x = TApplicationException()
2644 
      x.read(self._iprot)
2645 
      self._iprot.readMessageEnd()
2646 
      raise x
2647 
    result = addInvoiceNumber_result()
2648 
    result.read(self._iprot)
2649 
    self._iprot.readMessageEnd()
2650 
    if result.ex is not None:
2651 
      raise result.ex
2652 
    return
2653 
 
4910 phani.kuma 2654 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2655 
    """
3064 chandransh 2656 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2657 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2658 
 
1408 ankur.sing 2659 
    Parameters:
3064 chandransh 2660 
     - warehouseId
1408 ankur.sing 2661 
     - providerId
3064 chandransh 2662 
     - cod
4910 phani.kuma 2663 
     - orderIds
1408 ankur.sing 2664 
    """
4910 phani.kuma 2665 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2666 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2667 
 
4910 phani.kuma 2668 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2669 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2670 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2671 
    args.warehouseId = warehouseId
1408 ankur.sing 2672 
    args.providerId = providerId
3064 chandransh 2673 
    args.cod = cod
4910 phani.kuma 2674 
    args.orderIds = orderIds
1408 ankur.sing 2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
4910 phani.kuma 2679 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
4910 phani.kuma 2686 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
3431 rajveer 2689 
    if result.success is not None:
1408 ankur.sing 2690 
      return result.success
3431 rajveer 2691 
    if result.ex is not None:
3064 chandransh 2692 
      raise result.ex
4910 phani.kuma 2693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2694 
 
5713 rajveer 2695 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2696 
    """
2697 
    Parameters:
2698 
     - providerId
2699 
     - orderIds
5713 rajveer 2700 
     - awbs
5676 rajveer 2701 
    """
5713 rajveer 2702 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2703 
    return self.recv_markOrdersAsReturnedFromStore()
2704 
 
5713 rajveer 2705 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2706 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2707 
    args = markOrdersAsReturnedFromStore_args()
2708 
    args.providerId = providerId
2709 
    args.orderIds = orderIds
5713 rajveer 2710 
    args.awbs = awbs
5676 rajveer 2711 
    args.write(self._oprot)
2712 
    self._oprot.writeMessageEnd()
2713 
    self._oprot.trans.flush()
2714 
 
2715 
  def recv_markOrdersAsReturnedFromStore(self, ):
2716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2717 
    if mtype == TMessageType.EXCEPTION:
2718 
      x = TApplicationException()
2719 
      x.read(self._iprot)
2720 
      self._iprot.readMessageEnd()
2721 
      raise x
2722 
    result = markOrdersAsReturnedFromStore_result()
2723 
    result.read(self._iprot)
2724 
    self._iprot.readMessageEnd()
2725 
    if result.success is not None:
2726 
      return result.success
2727 
    if result.ex is not None:
2728 
      raise result.ex
2729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2730 
 
4910 phani.kuma 2731 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2732 
    """
4910 phani.kuma 2733 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2734 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2735 
 
2736 
    Parameters:
2737 
     - providerId
4910 phani.kuma 2738 
     - pickupDetails
4410 rajveer 2739 
    """
4910 phani.kuma 2740 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2741 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2742 
 
4910 phani.kuma 2743 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2744 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2745 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2746 
    args.providerId = providerId
4910 phani.kuma 2747 
    args.pickupDetails = pickupDetails
4410 rajveer 2748 
    args.write(self._oprot)
2749 
    self._oprot.writeMessageEnd()
2750 
    self._oprot.trans.flush()
2751 
 
4910 phani.kuma 2752 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2754 
    if mtype == TMessageType.EXCEPTION:
2755 
      x = TApplicationException()
2756 
      x.read(self._iprot)
2757 
      self._iprot.readMessageEnd()
2758 
      raise x
4910 phani.kuma 2759 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2760 
    result.read(self._iprot)
2761 
    self._iprot.readMessageEnd()
2762 
    if result.ex is not None:
2763 
      raise result.ex
4910 phani.kuma 2764 
    return
4410 rajveer 2765 
 
4910 phani.kuma 2766 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2767 
    """
3064 chandransh 2768 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2769 
 
94 ashish 2770 
    Parameters:
3064 chandransh 2771 
     - providerId
304 ashish 2772 
    """
4910 phani.kuma 2773 
    self.send_getOrdersNotPickedUp(providerId)
2774 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2775 
 
4910 phani.kuma 2776 
  def send_getOrdersNotPickedUp(self, providerId):
2777 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2778 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2779 
    args.providerId = providerId
304 ashish 2780 
    args.write(self._oprot)
2781 
    self._oprot.writeMessageEnd()
2782 
    self._oprot.trans.flush()
2783 
 
4910 phani.kuma 2784 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2786 
    if mtype == TMessageType.EXCEPTION:
2787 
      x = TApplicationException()
2788 
      x.read(self._iprot)
2789 
      self._iprot.readMessageEnd()
2790 
      raise x
4910 phani.kuma 2791 
    result = getOrdersNotPickedUp_result()
304 ashish 2792 
    result.read(self._iprot)
2793 
    self._iprot.readMessageEnd()
3431 rajveer 2794 
    if result.success is not None:
304 ashish 2795 
      return result.success
4910 phani.kuma 2796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2797 
 
3064 chandransh 2798 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2799 
    """
3064 chandransh 2800 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2801 
    the name of the receiver.
2802 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2803 
 
304 ashish 2804 
    Parameters:
3064 chandransh 2805 
     - providerId
2806 
     - deliveredOrders
304 ashish 2807 
    """
3064 chandransh 2808 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2809 
    self.recv_markOrdersAsDelivered()
304 ashish 2810 
 
3064 chandransh 2811 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2812 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2813 
    args = markOrdersAsDelivered_args()
2814 
    args.providerId = providerId
2815 
    args.deliveredOrders = deliveredOrders
304 ashish 2816 
    args.write(self._oprot)
2817 
    self._oprot.writeMessageEnd()
2818 
    self._oprot.trans.flush()
2819 
 
3064 chandransh 2820 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2822 
    if mtype == TMessageType.EXCEPTION:
2823 
      x = TApplicationException()
2824 
      x.read(self._iprot)
2825 
      self._iprot.readMessageEnd()
2826 
      raise x
3064 chandransh 2827 
    result = markOrdersAsDelivered_result()
304 ashish 2828 
    result.read(self._iprot)
2829 
    self._iprot.readMessageEnd()
3431 rajveer 2830 
    if result.ex is not None:
3064 chandransh 2831 
      raise result.ex
304 ashish 2832 
    return
2833 
 
4910 phani.kuma 2834 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2835 
    """
4910 phani.kuma 2836 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2837 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2838 
 
3064 chandransh 2839 
    Parameters:
2840 
     - providerId
2841 
     - returnedOrders
1596 ankur.sing 2842 
    """
4910 phani.kuma 2843 
    self.send_markAsRTOrders(providerId, returnedOrders)
2844 
    self.recv_markAsRTOrders()
304 ashish 2845 
 
4910 phani.kuma 2846 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2847 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2848 
    args = markAsRTOrders_args()
3064 chandransh 2849 
    args.providerId = providerId
2850 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2851 
    args.write(self._oprot)
2852 
    self._oprot.writeMessageEnd()
2853 
    self._oprot.trans.flush()
2854 
 
4910 phani.kuma 2855 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2857 
    if mtype == TMessageType.EXCEPTION:
2858 
      x = TApplicationException()
2859 
      x.read(self._iprot)
2860 
      self._iprot.readMessageEnd()
2861 
      raise x
4910 phani.kuma 2862 
    result = markAsRTOrders_result()
1596 ankur.sing 2863 
    result.read(self._iprot)
2864 
    self._iprot.readMessageEnd()
3431 rajveer 2865 
    if result.ex is not None:
3064 chandransh 2866 
      raise result.ex
2867 
    return
1596 ankur.sing 2868 
 
4910 phani.kuma 2869 
  def getRTOrders(self, providerId):
2870 
    """
2871 
    Returns a list of orders that were returned by courier.
2872 
 
2873 
    Parameters:
2874 
     - providerId
2875 
    """
2876 
    self.send_getRTOrders(providerId)
2877 
    return self.recv_getRTOrders()
2878 
 
2879 
  def send_getRTOrders(self, providerId):
2880 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2881 
    args = getRTOrders_args()
2882 
    args.providerId = providerId
2883 
    args.write(self._oprot)
2884 
    self._oprot.writeMessageEnd()
2885 
    self._oprot.trans.flush()
2886 
 
2887 
  def recv_getRTOrders(self, ):
2888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2889 
    if mtype == TMessageType.EXCEPTION:
2890 
      x = TApplicationException()
2891 
      x.read(self._iprot)
2892 
      self._iprot.readMessageEnd()
2893 
      raise x
2894 
    result = getRTOrders_result()
2895 
    result.read(self._iprot)
2896 
    self._iprot.readMessageEnd()
2897 
    if result.success is not None:
2898 
      return result.success
2899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2900 
 
3064 chandransh 2901 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2902 
    """
3064 chandransh 2903 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2904 
 
3064 chandransh 2905 
    Parameters:
2906 
     - providerId
2907 
     - undeliveredOrders
1627 ankur.sing 2908 
    """
3064 chandransh 2909 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2910 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2911 
 
3064 chandransh 2912 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2913 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2914 
    args = updateNonDeliveryReason_args()
2915 
    args.providerId = providerId
2916 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2917 
    args.write(self._oprot)
2918 
    self._oprot.writeMessageEnd()
2919 
    self._oprot.trans.flush()
2920 
 
3064 chandransh 2921 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2923 
    if mtype == TMessageType.EXCEPTION:
2924 
      x = TApplicationException()
2925 
      x.read(self._iprot)
2926 
      self._iprot.readMessageEnd()
2927 
      raise x
3064 chandransh 2928 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2929 
    result.read(self._iprot)
2930 
    self._iprot.readMessageEnd()
4910 phani.kuma 2931 
    if result.ex is not None:
2932 
      raise result.ex
2933 
    return
2934 
 
2935 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2936 
    """
2937 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2938 
 
2939 
    Parameters:
2940 
     - providerId
2941 
    """
2942 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2943 
    return self.recv_getNonDeliveredOrdersbyCourier()
2944 
 
2945 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2946 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2947 
    args = getNonDeliveredOrdersbyCourier_args()
2948 
    args.providerId = providerId
2949 
    args.write(self._oprot)
2950 
    self._oprot.writeMessageEnd()
2951 
    self._oprot.trans.flush()
2952 
 
2953 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2955 
    if mtype == TMessageType.EXCEPTION:
2956 
      x = TApplicationException()
2957 
      x.read(self._iprot)
2958 
      self._iprot.readMessageEnd()
2959 
      raise x
2960 
    result = getNonDeliveredOrdersbyCourier_result()
2961 
    result.read(self._iprot)
2962 
    self._iprot.readMessageEnd()
4581 phani.kuma 2963 
    if result.success is not None:
2964 
      return result.success
4910 phani.kuma 2965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
2966 
 
2967 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2968 
    """
2969 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
2970 
 
2971 
    Parameters:
2972 
     - providerId
2973 
     - local_connected_orders
2974 
    """
2975 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
2976 
    self.recv_markOrdersAsLocalConnected()
2977 
 
2978 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
2979 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
2980 
    args = markOrdersAsLocalConnected_args()
2981 
    args.providerId = providerId
2982 
    args.local_connected_orders = local_connected_orders
2983 
    args.write(self._oprot)
2984 
    self._oprot.writeMessageEnd()
2985 
    self._oprot.trans.flush()
2986 
 
2987 
  def recv_markOrdersAsLocalConnected(self, ):
2988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2989 
    if mtype == TMessageType.EXCEPTION:
2990 
      x = TApplicationException()
2991 
      x.read(self._iprot)
2992 
      self._iprot.readMessageEnd()
2993 
      raise x
2994 
    result = markOrdersAsLocalConnected_result()
2995 
    result.read(self._iprot)
2996 
    self._iprot.readMessageEnd()
3431 rajveer 2997 
    if result.ex is not None:
3064 chandransh 2998 
      raise result.ex
4910 phani.kuma 2999 
    return
1627 ankur.sing 3000 
 
4910 phani.kuma 3001 
  def getOrdersNotLocalConnected(self, providerId):
3002 
    """
3003 
    Returns a list of orders that were picked up or shipped but pending local connection.
3004 
 
3005 
    Parameters:
3006 
     - providerId
3007 
    """
3008 
    self.send_getOrdersNotLocalConnected(providerId)
3009 
    return self.recv_getOrdersNotLocalConnected()
3010 
 
3011 
  def send_getOrdersNotLocalConnected(self, providerId):
3012 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3013 
    args = getOrdersNotLocalConnected_args()
3014 
    args.providerId = providerId
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_getOrdersNotLocalConnected(self, ):
3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3026 
    result = getOrdersNotLocalConnected_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3029 
    if result.success is not None:
3030 
      return result.success
3031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3032 
 
3033 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3034 
    """
3035 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3036 
 
3037 
    Parameters:
3038 
     - providerId
3039 
     - destination_city_reached_orders
3040 
    """
3041 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3042 
    self.recv_markOrdersAsDestinationCityReached()
3043 
 
3044 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3045 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3046 
    args = markOrdersAsDestinationCityReached_args()
3047 
    args.providerId = providerId
3048 
    args.destination_city_reached_orders = destination_city_reached_orders
3049 
    args.write(self._oprot)
3050 
    self._oprot.writeMessageEnd()
3051 
    self._oprot.trans.flush()
3052 
 
3053 
  def recv_markOrdersAsDestinationCityReached(self, ):
3054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3055 
    if mtype == TMessageType.EXCEPTION:
3056 
      x = TApplicationException()
3057 
      x.read(self._iprot)
3058 
      self._iprot.readMessageEnd()
3059 
      raise x
3060 
    result = markOrdersAsDestinationCityReached_result()
3061 
    result.read(self._iprot)
3062 
    self._iprot.readMessageEnd()
3063 
    if result.ex is not None:
3064 
      raise result.ex
3065 
    return
3066 
 
3067 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3068 
    """
3069 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3070 
 
3071 
    Parameters:
3072 
     - providerId
3073 
     - first_atdl_orders
3074 
    """
3075 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3076 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3077 
 
3078 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3079 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3080 
    args = markOrdersAsFirstDeliveryAttempted_args()
3081 
    args.providerId = providerId
3082 
    args.first_atdl_orders = first_atdl_orders
3083 
    args.write(self._oprot)
3084 
    self._oprot.writeMessageEnd()
3085 
    self._oprot.trans.flush()
3086 
 
3087 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3089 
    if mtype == TMessageType.EXCEPTION:
3090 
      x = TApplicationException()
3091 
      x.read(self._iprot)
3092 
      self._iprot.readMessageEnd()
3093 
      raise x
3094 
    result = markOrdersAsFirstDeliveryAttempted_result()
3095 
    result.read(self._iprot)
3096 
    self._iprot.readMessageEnd()
3097 
    if result.ex is not None:
3098 
      raise result.ex
3099 
    return
3100 
 
3064 chandransh 3101 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3102 
    """
3064 chandransh 3103 
    Returns the list of orders whose delivery time has passed but have not been
3104 
    delivered yet for the given provider and warehouse. To get a complete list of
3105 
    undelivered orders, pass them as -1.
3106 
    Returns an empty list if no such orders exist.
3431 rajveer 3107 
 
1886 ankur.sing 3108 
    Parameters:
3064 chandransh 3109 
     - providerId
3110 
     - warehouseId
1886 ankur.sing 3111 
    """
3064 chandransh 3112 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3113 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3114 
 
3064 chandransh 3115 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3116 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3117 
    args = getUndeliveredOrders_args()
3118 
    args.providerId = providerId
3119 
    args.warehouseId = warehouseId
1886 ankur.sing 3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3064 chandransh 3124 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3064 chandransh 3131 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3431 rajveer 3134 
    if result.success is not None:
1886 ankur.sing 3135 
      return result.success
3064 chandransh 3136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3137 
 
4783 phani.kuma 3138 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3139 
    """
3140 
    Returns the list of orders whose expected delivery date has passed but have not been
3141 
    delivered yet.
3142 
    Returns an empty list if no such orders exist.
3143 
    """
3144 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3145 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3146 
 
3147 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3148 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3149 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3150 
    args.write(self._oprot)
3151 
    self._oprot.writeMessageEnd()
3152 
    self._oprot.trans.flush()
3153 
 
3154 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3156 
    if mtype == TMessageType.EXCEPTION:
3157 
      x = TApplicationException()
3158 
      x.read(self._iprot)
3159 
      self._iprot.readMessageEnd()
3160 
      raise x
3161 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3162 
    result.read(self._iprot)
3163 
    self._iprot.readMessageEnd()
3164 
    if result.success is not None:
3165 
      return result.success
3166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3167 
 
2536 chandransh 3168 
  def toggleDOAFlag(self, orderId):
3169 
    """
3170 
    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.
3171 
    Returns the final flag status.
3172 
    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 3173 
 
2536 chandransh 3174 
    Parameters:
3175 
     - orderId
3176 
    """
3177 
    self.send_toggleDOAFlag(orderId)
3178 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3179 
 
2536 chandransh 3180 
  def send_toggleDOAFlag(self, orderId):
3181 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3182 
    args = toggleDOAFlag_args()
3183 
    args.orderId = orderId
3184 
    args.write(self._oprot)
3185 
    self._oprot.writeMessageEnd()
3186 
    self._oprot.trans.flush()
3187 
 
3188 
  def recv_toggleDOAFlag(self, ):
3189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3190 
    if mtype == TMessageType.EXCEPTION:
3191 
      x = TApplicationException()
3192 
      x.read(self._iprot)
3193 
      self._iprot.readMessageEnd()
3194 
      raise x
3195 
    result = toggleDOAFlag_result()
3196 
    result.read(self._iprot)
3197 
    self._iprot.readMessageEnd()
3431 rajveer 3198 
    if result.success is not None:
2536 chandransh 3199 
      return result.success
3431 rajveer 3200 
    if result.ex is not None:
2536 chandransh 3201 
      raise result.ex
3202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3203 
 
4712 rajveer 3204 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3205 
    """
3206 
    Parameters:
3207 
     - orderId
3208 
     - deliveryTimestamp
3209 
     - receiver
3210 
    """
3211 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3212 
    self.recv_markOrderAsDelivered()
3213 
 
3214 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3215 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3216 
    args = markOrderAsDelivered_args()
3217 
    args.orderId = orderId
3218 
    args.deliveryTimestamp = deliveryTimestamp
3219 
    args.receiver = receiver
3220 
    args.write(self._oprot)
3221 
    self._oprot.writeMessageEnd()
3222 
    self._oprot.trans.flush()
3223 
 
3224 
  def recv_markOrderAsDelivered(self, ):
3225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3226 
    if mtype == TMessageType.EXCEPTION:
3227 
      x = TApplicationException()
3228 
      x.read(self._iprot)
3229 
      self._iprot.readMessageEnd()
3230 
      raise x
3231 
    result = markOrderAsDelivered_result()
3232 
    result.read(self._iprot)
3233 
    self._iprot.readMessageEnd()
3234 
    if result.ex is not None:
3235 
      raise result.ex
3236 
    return
3237 
 
5553 rajveer 3238 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3239 
    """
3240 
    Parameters:
3241 
     - orderId
3242 
     - deliveryTimestamp
3243 
    """
3244 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3245 
    self.recv_markOrderAsReceivedAtStore()
3246 
 
3247 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3248 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3249 
    args = markOrderAsReceivedAtStore_args()
3250 
    args.orderId = orderId
3251 
    args.deliveryTimestamp = deliveryTimestamp
3252 
    args.write(self._oprot)
3253 
    self._oprot.writeMessageEnd()
3254 
    self._oprot.trans.flush()
3255 
 
3256 
  def recv_markOrderAsReceivedAtStore(self, ):
3257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3258 
    if mtype == TMessageType.EXCEPTION:
3259 
      x = TApplicationException()
3260 
      x.read(self._iprot)
3261 
      self._iprot.readMessageEnd()
3262 
      raise x
3263 
    result = markOrderAsReceivedAtStore_result()
3264 
    result.read(self._iprot)
3265 
    self._iprot.readMessageEnd()
3266 
    if result.ex is not None:
3267 
      raise result.ex
3268 
    return
3269 
 
4454 rajveer 3270 
  def markOrderDoaRequestReceived(self, orderId):
3271 
    """
3272 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3273 
 
3274 
    Parameters:
3275 
     - orderId
3276 
    """
3277 
    self.send_markOrderDoaRequestReceived(orderId)
3278 
    return self.recv_markOrderDoaRequestReceived()
3279 
 
3280 
  def send_markOrderDoaRequestReceived(self, orderId):
3281 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3282 
    args = markOrderDoaRequestReceived_args()
3283 
    args.orderId = orderId
3284 
    args.write(self._oprot)
3285 
    self._oprot.writeMessageEnd()
3286 
    self._oprot.trans.flush()
3287 
 
3288 
  def recv_markOrderDoaRequestReceived(self, ):
3289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3290 
    if mtype == TMessageType.EXCEPTION:
3291 
      x = TApplicationException()
3292 
      x.read(self._iprot)
3293 
      self._iprot.readMessageEnd()
3294 
      raise x
3295 
    result = markOrderDoaRequestReceived_result()
3296 
    result.read(self._iprot)
3297 
    self._iprot.readMessageEnd()
3298 
    if result.success is not None:
3299 
      return result.success
3300 
    if result.ex is not None:
3301 
      raise result.ex
3302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3303 
 
3304 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3305 
    """
3306 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3307 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3308 
 
3309 
    Parameters:
3310 
     - orderId
3311 
     - isAuthorized
3312 
    """
3313 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3314 
    return self.recv_markOrderDoaRequestAuthorized()
3315 
 
3316 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3317 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3318 
    args = markOrderDoaRequestAuthorized_args()
3319 
    args.orderId = orderId
3320 
    args.isAuthorized = isAuthorized
3321 
    args.write(self._oprot)
3322 
    self._oprot.writeMessageEnd()
3323 
    self._oprot.trans.flush()
3324 
 
3325 
  def recv_markOrderDoaRequestAuthorized(self, ):
3326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3327 
    if mtype == TMessageType.EXCEPTION:
3328 
      x = TApplicationException()
3329 
      x.read(self._iprot)
3330 
      self._iprot.readMessageEnd()
3331 
      raise x
3332 
    result = markOrderDoaRequestAuthorized_result()
3333 
    result.read(self._iprot)
3334 
    self._iprot.readMessageEnd()
3335 
    if result.success is not None:
3336 
      return result.success
3337 
    if result.ex is not None:
3338 
      raise result.ex
3339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3340 
 
4488 rajveer 3341 
  def markOrderReturnRequestReceived(self, orderId):
3342 
    """
3343 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3344 
 
3345 
    Parameters:
3346 
     - orderId
3347 
    """
3348 
    self.send_markOrderReturnRequestReceived(orderId)
3349 
    return self.recv_markOrderReturnRequestReceived()
3350 
 
3351 
  def send_markOrderReturnRequestReceived(self, orderId):
3352 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3353 
    args = markOrderReturnRequestReceived_args()
3354 
    args.orderId = orderId
3355 
    args.write(self._oprot)
3356 
    self._oprot.writeMessageEnd()
3357 
    self._oprot.trans.flush()
3358 
 
3359 
  def recv_markOrderReturnRequestReceived(self, ):
3360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3361 
    if mtype == TMessageType.EXCEPTION:
3362 
      x = TApplicationException()
3363 
      x.read(self._iprot)
3364 
      self._iprot.readMessageEnd()
3365 
      raise x
3366 
    result = markOrderReturnRequestReceived_result()
3367 
    result.read(self._iprot)
3368 
    self._iprot.readMessageEnd()
3369 
    if result.success is not None:
3370 
      return result.success
3371 
    if result.ex is not None:
3372 
      raise result.ex
3373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3374 
 
3375 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3376 
    """
3377 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3378 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3379 
 
3380 
    Parameters:
3381 
     - orderId
3382 
     - isAuthorized
3383 
    """
3384 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3385 
    return self.recv_markOrderReturnRequestAuthorized()
3386 
 
3387 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3388 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3389 
    args = markOrderReturnRequestAuthorized_args()
3390 
    args.orderId = orderId
3391 
    args.isAuthorized = isAuthorized
3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_markOrderReturnRequestAuthorized(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = markOrderReturnRequestAuthorized_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3406 
    if result.success is not None:
3407 
      return result.success
3408 
    if result.ex is not None:
3409 
      raise result.ex
3410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3411 
 
4579 rajveer 3412 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3413 
    """
3414 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3415 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3416 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3417 
    For any other status, it returns false.
3418 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3419 
 
2536 chandransh 3420 
    Parameters:
3421 
     - orderId
4579 rajveer 3422 
     - providerId
2536 chandransh 3423 
    """
4579 rajveer 3424 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3425 
    return self.recv_requestPickupNumber()
3426 
 
4579 rajveer 3427 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3428 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3429 
    args = requestPickupNumber_args()
3430 
    args.orderId = orderId
4579 rajveer 3431 
    args.providerId = providerId
2536 chandransh 3432 
    args.write(self._oprot)
3433 
    self._oprot.writeMessageEnd()
3434 
    self._oprot.trans.flush()
3435 
 
3436 
  def recv_requestPickupNumber(self, ):
3437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3438 
    if mtype == TMessageType.EXCEPTION:
3439 
      x = TApplicationException()
3440 
      x.read(self._iprot)
3441 
      self._iprot.readMessageEnd()
3442 
      raise x
3443 
    result = requestPickupNumber_result()
3444 
    result.read(self._iprot)
3445 
    self._iprot.readMessageEnd()
3431 rajveer 3446 
    if result.success is not None:
2536 chandransh 3447 
      return result.success
3431 rajveer 3448 
    if result.ex is not None:
2536 chandransh 3449 
      raise result.ex
3450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3451 
 
4602 rajveer 3452 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3453 
    """
4452 rajveer 3454 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3455 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3456 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3457 
    	3. Returns true
2591 chandransh 3458 
    If the order is in any other status, it returns false.
2536 chandransh 3459 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3460 
 
2536 chandransh 3461 
    Parameters:
3462 
     - orderId
3463 
     - pickupNumber
4602 rajveer 3464 
     - providerId
2536 chandransh 3465 
    """
4602 rajveer 3466 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3467 
    return self.recv_authorizePickup()
3468 
 
4602 rajveer 3469 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3470 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3471 
    args = authorizePickup_args()
3472 
    args.orderId = orderId
3473 
    args.pickupNumber = pickupNumber
4602 rajveer 3474 
    args.providerId = providerId
2536 chandransh 3475 
    args.write(self._oprot)
3476 
    self._oprot.writeMessageEnd()
3477 
    self._oprot.trans.flush()
3478 
 
3479 
  def recv_authorizePickup(self, ):
3480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3481 
    if mtype == TMessageType.EXCEPTION:
3482 
      x = TApplicationException()
3483 
      x.read(self._iprot)
3484 
      self._iprot.readMessageEnd()
3485 
      raise x
3486 
    result = authorizePickup_result()
3487 
    result.read(self._iprot)
3488 
    self._iprot.readMessageEnd()
3431 rajveer 3489 
    if result.success is not None:
2536 chandransh 3490 
      return result.success
3431 rajveer 3491 
    if result.ex is not None:
2536 chandransh 3492 
      raise result.ex
3493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3494 
 
2764 chandransh 3495 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3496 
    """
3497 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3498 
 
2764 chandransh 3499 
    Parameters:
3500 
     - providerId
3501 
     - pickupDetails
3502 
    """
3503 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3504 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3505 
 
3506 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3507 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3508 
    args = markDoasAsPickedUp_args()
3509 
    args.providerId = providerId
3510 
    args.pickupDetails = pickupDetails
3511 
    args.write(self._oprot)
3512 
    self._oprot.writeMessageEnd()
3513 
    self._oprot.trans.flush()
3514 
 
3515 
  def recv_markDoasAsPickedUp(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 = markDoasAsPickedUp_result()
3523 
    result.read(self._iprot)
3524 
    self._iprot.readMessageEnd()
4910 phani.kuma 3525 
    return
3526 
 
3527 
  def getDoasNotPickedUp(self, providerId):
3528 
    """
3529 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3530 
 
3531 
    Parameters:
3532 
     - providerId
3533 
    """
3534 
    self.send_getDoasNotPickedUp(providerId)
3535 
    return self.recv_getDoasNotPickedUp()
3536 
 
3537 
  def send_getDoasNotPickedUp(self, providerId):
3538 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3539 
    args = getDoasNotPickedUp_args()
3540 
    args.providerId = providerId
3541 
    args.write(self._oprot)
3542 
    self._oprot.writeMessageEnd()
3543 
    self._oprot.trans.flush()
3544 
 
3545 
  def recv_getDoasNotPickedUp(self, ):
3546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3547 
    if mtype == TMessageType.EXCEPTION:
3548 
      x = TApplicationException()
3549 
      x.read(self._iprot)
3550 
      self._iprot.readMessageEnd()
3551 
      raise x
3552 
    result = getDoasNotPickedUp_result()
3553 
    result.read(self._iprot)
3554 
    self._iprot.readMessageEnd()
3431 rajveer 3555 
    if result.success is not None:
2764 chandransh 3556 
      return result.success
4910 phani.kuma 3557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3558 
 
4741 phani.kuma 3559 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3560 
    """
3561 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3562 
 
3563 
    Parameters:
3564 
     - providerId
3565 
     - pickupDetails
3566 
    """
3567 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3568 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3569 
 
3570 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3571 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3572 
    args = markReturnOrdersAsPickedUp_args()
3573 
    args.providerId = providerId
3574 
    args.pickupDetails = pickupDetails
3575 
    args.write(self._oprot)
3576 
    self._oprot.writeMessageEnd()
3577 
    self._oprot.trans.flush()
3578 
 
3579 
  def recv_markReturnOrdersAsPickedUp(self, ):
3580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3581 
    if mtype == TMessageType.EXCEPTION:
3582 
      x = TApplicationException()
3583 
      x.read(self._iprot)
3584 
      self._iprot.readMessageEnd()
3585 
      raise x
3586 
    result = markReturnOrdersAsPickedUp_result()
3587 
    result.read(self._iprot)
3588 
    self._iprot.readMessageEnd()
4910 phani.kuma 3589 
    return
3590 
 
3591 
  def getReturnOrdersNotPickedUp(self, providerId):
3592 
    """
3593 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3594 
 
3595 
    Parameters:
3596 
     - providerId
3597 
    """
3598 
    self.send_getReturnOrdersNotPickedUp(providerId)
3599 
    return self.recv_getReturnOrdersNotPickedUp()
3600 
 
3601 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3602 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3603 
    args = getReturnOrdersNotPickedUp_args()
3604 
    args.providerId = providerId
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_getReturnOrdersNotPickedUp(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = getReturnOrdersNotPickedUp_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
4741 phani.kuma 3619 
    if result.success is not None:
3620 
      return result.success
4910 phani.kuma 3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3622 
 
4479 rajveer 3623 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3624 
    """
4452 rajveer 3625 
    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 3626 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3627 
    If the order is in any other state, it returns false.
3628 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3629 
 
2591 chandransh 3630 
    Parameters:
3631 
     - orderId
4479 rajveer 3632 
     - receiveCondition
2591 chandransh 3633 
    """
4479 rajveer 3634 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3635 
    return self.recv_receiveReturn()
2536 chandransh 3636 
 
4479 rajveer 3637 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3638 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3639 
    args = receiveReturn_args()
2591 chandransh 3640 
    args.orderId = orderId
4479 rajveer 3641 
    args.receiveCondition = receiveCondition
2591 chandransh 3642 
    args.write(self._oprot)
3643 
    self._oprot.writeMessageEnd()
3644 
    self._oprot.trans.flush()
3645 
 
2616 chandransh 3646 
  def recv_receiveReturn(self, ):
2591 chandransh 3647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3648 
    if mtype == TMessageType.EXCEPTION:
3649 
      x = TApplicationException()
3650 
      x.read(self._iprot)
3651 
      self._iprot.readMessageEnd()
3652 
      raise x
2616 chandransh 3653 
    result = receiveReturn_result()
2591 chandransh 3654 
    result.read(self._iprot)
3655 
    self._iprot.readMessageEnd()
3431 rajveer 3656 
    if result.success is not None:
2591 chandransh 3657 
      return result.success
3431 rajveer 3658 
    if result.ex is not None:
2591 chandransh 3659 
      raise result.ex
2616 chandransh 3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3661 
 
3662 
  def validateDoa(self, orderId, isValid):
3663 
    """
4452 rajveer 3664 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3665 
    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 3666 
    If the order is in any other state, it returns false.
3667 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3668 
 
2591 chandransh 3669 
    Parameters:
3670 
     - orderId
3671 
     - isValid
3672 
    """
3673 
    self.send_validateDoa(orderId, isValid)
3674 
    return self.recv_validateDoa()
3675 
 
3676 
  def send_validateDoa(self, orderId, isValid):
3677 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3678 
    args = validateDoa_args()
3679 
    args.orderId = orderId
3680 
    args.isValid = isValid
3681 
    args.write(self._oprot)
3682 
    self._oprot.writeMessageEnd()
3683 
    self._oprot.trans.flush()
3684 
 
3685 
  def recv_validateDoa(self, ):
3686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3687 
    if mtype == TMessageType.EXCEPTION:
3688 
      x = TApplicationException()
3689 
      x.read(self._iprot)
3690 
      self._iprot.readMessageEnd()
3691 
      raise x
3692 
    result = validateDoa_result()
3693 
    result.read(self._iprot)
3694 
    self._iprot.readMessageEnd()
3431 rajveer 3695 
    if result.success is not None:
2591 chandransh 3696 
      return result.success
3431 rajveer 3697 
    if result.ex is not None:
2591 chandransh 3698 
      raise result.ex
3699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3700 
 
4495 rajveer 3701 
  def validateReturnProduct(self, orderId, isUsable):
3702 
    """
3703 
    Parameters:
3704 
     - orderId
3705 
     - isUsable
3706 
    """
3707 
    self.send_validateReturnProduct(orderId, isUsable)
3708 
    return self.recv_validateReturnProduct()
3709 
 
3710 
  def send_validateReturnProduct(self, orderId, isUsable):
3711 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3712 
    args = validateReturnProduct_args()
3713 
    args.orderId = orderId
3714 
    args.isUsable = isUsable
3715 
    args.write(self._oprot)
3716 
    self._oprot.writeMessageEnd()
3717 
    self._oprot.trans.flush()
3718 
 
3719 
  def recv_validateReturnProduct(self, ):
3720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3721 
    if mtype == TMessageType.EXCEPTION:
3722 
      x = TApplicationException()
3723 
      x.read(self._iprot)
3724 
      self._iprot.readMessageEnd()
3725 
      raise x
3726 
    result = validateReturnProduct_result()
3727 
    result.read(self._iprot)
3728 
    self._iprot.readMessageEnd()
3729 
    if result.success is not None:
3730 
      return result.success
3731 
    if result.ex is not None:
3732 
      raise result.ex
3733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3734 
 
2616 chandransh 3735 
  def reshipOrder(self, orderId):
3736 
    """
4484 rajveer 3737 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3738 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3739 
    	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 3740 
 
3741 
    If the order is in DOA_CERT_VALID state, it does the following:
3742 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3743 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3744 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3745 
 
2616 chandransh 3746 
    Returns the id of the newly created order.
3431 rajveer 3747 
 
2616 chandransh 3748 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3749 
 
2616 chandransh 3750 
    Parameters:
3751 
     - orderId
3752 
    """
3753 
    self.send_reshipOrder(orderId)
3754 
    return self.recv_reshipOrder()
2591 chandransh 3755 
 
2616 chandransh 3756 
  def send_reshipOrder(self, orderId):
3757 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3758 
    args = reshipOrder_args()
3759 
    args.orderId = orderId
3760 
    args.write(self._oprot)
3761 
    self._oprot.writeMessageEnd()
3762 
    self._oprot.trans.flush()
3763 
 
3764 
  def recv_reshipOrder(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 = reshipOrder_result()
3772 
    result.read(self._iprot)
3773 
    self._iprot.readMessageEnd()
3431 rajveer 3774 
    if result.success is not None:
2616 chandransh 3775 
      return result.success
3431 rajveer 3776 
    if result.ex is not None:
2616 chandransh 3777 
      raise result.ex
3778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3779 
 
3226 chandransh 3780 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3781 
    """
4484 rajveer 3782 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3783 
    	1. Creates a refund request for batch processing.
3784 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3785 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3786 
 
2616 chandransh 3787 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3788 
    	1. Creates a refund request for batch processing.
3226 chandransh 3789 
    	2. Cancels the reservation of the item in the warehouse.
3790 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3791 
 
3226 chandransh 3792 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3793 
    	1. Cancels the reservation of the item in the warehouse.
3794 
    	2. Marks the current order as CANCELED.
3795 
 
3796 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3797 
 
2616 chandransh 3798 
    Returns True if it is successful, False otherwise.
3431 rajveer 3799 
 
2616 chandransh 3800 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3801 
 
2616 chandransh 3802 
    Parameters:
3803 
     - orderId
3226 chandransh 3804 
     - refundedBy
3805 
     - reason
2616 chandransh 3806 
    """
3226 chandransh 3807 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3808 
    return self.recv_refundOrder()
3809 
 
3226 chandransh 3810 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3811 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3812 
    args = refundOrder_args()
3813 
    args.orderId = orderId
3226 chandransh 3814 
    args.refundedBy = refundedBy
3815 
    args.reason = reason
2616 chandransh 3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_refundOrder(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = refundOrder_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
3431 rajveer 3830 
    if result.success is not None:
2616 chandransh 3831 
      return result.success
3431 rajveer 3832 
    if result.ex is not None:
2616 chandransh 3833 
      raise result.ex
3834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3835 
 
2690 chandransh 3836 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3837 
    """
3838 
    Get all return orders created between the from and to dates for the given warehouse.
3839 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3840 
 
2690 chandransh 3841 
    Parameters:
3842 
     - warehouseId
3843 
     - fromDate
3844 
     - toDate
3845 
    """
3846 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3847 
    return self.recv_getReturnOrders()
2616 chandransh 3848 
 
2690 chandransh 3849 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3850 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3851 
    args = getReturnOrders_args()
3852 
    args.warehouseId = warehouseId
3853 
    args.fromDate = fromDate
3854 
    args.toDate = toDate
3855 
    args.write(self._oprot)
3856 
    self._oprot.writeMessageEnd()
3857 
    self._oprot.trans.flush()
3858 
 
3859 
  def recv_getReturnOrders(self, ):
3860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3861 
    if mtype == TMessageType.EXCEPTION:
3862 
      x = TApplicationException()
3863 
      x.read(self._iprot)
3864 
      self._iprot.readMessageEnd()
3865 
      raise x
3866 
    result = getReturnOrders_result()
3867 
    result.read(self._iprot)
3868 
    self._iprot.readMessageEnd()
3431 rajveer 3869 
    if result.success is not None:
2690 chandransh 3870 
      return result.success
3871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3872 
 
5481 phani.kuma 3873 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3874 
    """
3875 
    Get all return orders created between the from and to dates.
3876 
 
3877 
    Parameters:
3878 
     - onlyNotProcessed
3879 
     - fromDate
3880 
     - toDate
3881 
    """
3882 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3883 
    return self.recv_getAllReturnOrders()
3884 
 
3885 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3886 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3887 
    args = getAllReturnOrders_args()
3888 
    args.onlyNotProcessed = onlyNotProcessed
3889 
    args.fromDate = fromDate
3890 
    args.toDate = toDate
3891 
    args.write(self._oprot)
3892 
    self._oprot.writeMessageEnd()
3893 
    self._oprot.trans.flush()
3894 
 
3895 
  def recv_getAllReturnOrders(self, ):
3896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3897 
    if mtype == TMessageType.EXCEPTION:
3898 
      x = TApplicationException()
3899 
      x.read(self._iprot)
3900 
      self._iprot.readMessageEnd()
3901 
      raise x
3902 
    result = getAllReturnOrders_result()
3903 
    result.read(self._iprot)
3904 
    self._iprot.readMessageEnd()
3905 
    if result.success is not None:
3906 
      return result.success
3907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3908 
 
2700 chandransh 3909 
  def getReturnOrder(self, id):
3910 
    """
3911 
    Returns the ReturnOrder corresponding to the given id.
3912 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3913 
 
2700 chandransh 3914 
    Parameters:
3915 
     - id
3916 
    """
3917 
    self.send_getReturnOrder(id)
3918 
    return self.recv_getReturnOrder()
3919 
 
3920 
  def send_getReturnOrder(self, id):
3921 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3922 
    args = getReturnOrder_args()
3923 
    args.id = id
3924 
    args.write(self._oprot)
3925 
    self._oprot.writeMessageEnd()
3926 
    self._oprot.trans.flush()
3927 
 
3928 
  def recv_getReturnOrder(self, ):
3929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3930 
    if mtype == TMessageType.EXCEPTION:
3931 
      x = TApplicationException()
3932 
      x.read(self._iprot)
3933 
      self._iprot.readMessageEnd()
3934 
      raise x
3935 
    result = getReturnOrder_result()
3936 
    result.read(self._iprot)
3937 
    self._iprot.readMessageEnd()
3431 rajveer 3938 
    if result.success is not None:
2700 chandransh 3939 
      return result.success
3431 rajveer 3940 
    if result.ex is not None:
2700 chandransh 3941 
      raise result.ex
3942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3943 
 
2690 chandransh 3944 
  def processReturn(self, returnOrderId):
3945 
    """
3946 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3947 
 
2690 chandransh 3948 
    Parameters:
3949 
     - returnOrderId
3950 
    """
3951 
    self.send_processReturn(returnOrderId)
3952 
    self.recv_processReturn()
3953 
 
3954 
  def send_processReturn(self, returnOrderId):
3955 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3956 
    args = processReturn_args()
3957 
    args.returnOrderId = returnOrderId
3958 
    args.write(self._oprot)
3959 
    self._oprot.writeMessageEnd()
3960 
    self._oprot.trans.flush()
3961 
 
3962 
  def recv_processReturn(self, ):
3963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3964 
    if mtype == TMessageType.EXCEPTION:
3965 
      x = TApplicationException()
3966 
      x.read(self._iprot)
3967 
      self._iprot.readMessageEnd()
3968 
      raise x
3969 
    result = processReturn_result()
3970 
    result.read(self._iprot)
3971 
    self._iprot.readMessageEnd()
3431 rajveer 3972 
    if result.ex is not None:
2690 chandransh 3973 
      raise result.ex
3974 
    return
3975 
 
3451 chandransh 3976 
  def updateWeight(self, orderId, weight):
3977 
    """
3978 
    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 3979 
 
3451 chandransh 3980 
    Parameters:
3981 
     - orderId
3982 
     - weight
3983 
    """
3984 
    self.send_updateWeight(orderId, weight)
3985 
    return self.recv_updateWeight()
3986 
 
3987 
  def send_updateWeight(self, orderId, weight):
3988 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
3989 
    args = updateWeight_args()
3990 
    args.orderId = orderId
3991 
    args.weight = weight
3992 
    args.write(self._oprot)
3993 
    self._oprot.writeMessageEnd()
3994 
    self._oprot.trans.flush()
3995 
 
3996 
  def recv_updateWeight(self, ):
3997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3998 
    if mtype == TMessageType.EXCEPTION:
3999 
      x = TApplicationException()
4000 
      x.read(self._iprot)
4001 
      self._iprot.readMessageEnd()
4002 
      raise x
4003 
    result = updateWeight_result()
4004 
    result.read(self._iprot)
4005 
    self._iprot.readMessageEnd()
4006 
    if result.success is not None:
4007 
      return result.success
4008 
    if result.ex is not None:
4009 
      raise result.ex
4010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4011 
 
3469 chandransh 4012 
  def changeItem(self, orderId, itemId):
4013 
    """
4014 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4015 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4016 
 
3469 chandransh 4017 
    Parameters:
4018 
     - orderId
4019 
     - itemId
4020 
    """
4021 
    self.send_changeItem(orderId, itemId)
4022 
    return self.recv_changeItem()
4023 
 
4024 
  def send_changeItem(self, orderId, itemId):
4025 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4026 
    args = changeItem_args()
4027 
    args.orderId = orderId
4028 
    args.itemId = itemId
4029 
    args.write(self._oprot)
4030 
    self._oprot.writeMessageEnd()
4031 
    self._oprot.trans.flush()
4032 
 
4033 
  def recv_changeItem(self, ):
4034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4035 
    if mtype == TMessageType.EXCEPTION:
4036 
      x = TApplicationException()
4037 
      x.read(self._iprot)
4038 
      self._iprot.readMessageEnd()
4039 
      raise x
4040 
    result = changeItem_result()
4041 
    result.read(self._iprot)
4042 
    self._iprot.readMessageEnd()
4043 
    if result.success is not None:
4044 
      return result.success
4045 
    if result.ex is not None:
4046 
      raise result.ex
4047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4048 
 
4049 
  def shiftToWarehouse(self, orderId, warehouseId):
4050 
    """
4051 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4052 
 
4053 
    Parameters:
4054 
     - orderId
4055 
     - warehouseId
4056 
    """
4057 
    self.send_shiftToWarehouse(orderId, warehouseId)
4058 
    return self.recv_shiftToWarehouse()
4059 
 
4060 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4061 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4062 
    args = shiftToWarehouse_args()
4063 
    args.orderId = orderId
4064 
    args.warehouseId = warehouseId
4065 
    args.write(self._oprot)
4066 
    self._oprot.writeMessageEnd()
4067 
    self._oprot.trans.flush()
4068 
 
4069 
  def recv_shiftToWarehouse(self, ):
4070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4071 
    if mtype == TMessageType.EXCEPTION:
4072 
      x = TApplicationException()
4073 
      x.read(self._iprot)
4074 
      self._iprot.readMessageEnd()
4075 
      raise x
4076 
    result = shiftToWarehouse_result()
4077 
    result.read(self._iprot)
4078 
    self._iprot.readMessageEnd()
4079 
    if result.success is not None:
4080 
      return result.success
4081 
    if result.ex is not None:
4082 
      raise result.ex
4083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4084 
 
4647 rajveer 4085 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4086 
    """
4087 
    Adds the given delay reason to the given order.
3986 chandransh 4088 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4089 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4090 
 
3553 chandransh 4091 
    Parameters:
4092 
     - orderId
4093 
     - delayReason
3986 chandransh 4094 
     - furtherDelay
4647 rajveer 4095 
     - delayReasonText
3553 chandransh 4096 
    """
4647 rajveer 4097 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4098 
    return self.recv_addDelayReason()
4099 
 
4647 rajveer 4100 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4101 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4102 
    args = addDelayReason_args()
4103 
    args.orderId = orderId
4104 
    args.delayReason = delayReason
3986 chandransh 4105 
    args.furtherDelay = furtherDelay
4647 rajveer 4106 
    args.delayReasonText = delayReasonText
3553 chandransh 4107 
    args.write(self._oprot)
4108 
    self._oprot.writeMessageEnd()
4109 
    self._oprot.trans.flush()
4110 
 
4111 
  def recv_addDelayReason(self, ):
4112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4113 
    if mtype == TMessageType.EXCEPTION:
4114 
      x = TApplicationException()
4115 
      x.read(self._iprot)
4116 
      self._iprot.readMessageEnd()
4117 
      raise x
4118 
    result = addDelayReason_result()
4119 
    result.read(self._iprot)
4120 
    self._iprot.readMessageEnd()
4121 
    if result.success is not None:
4122 
      return result.success
4123 
    if result.ex is not None:
4124 
      raise result.ex
4125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4126 
 
3956 chandransh 4127 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4128 
    """
4129 
    Marks the COD orders with given AWB nos. as having been processed.
4130 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4131 
 
3956 chandransh 4132 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4133 
    1. There is no order corresponding to an AWB number.
4134 
    2. The captured amount for a payment exceeds the total payment.
4135 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4136 
 
4137 
    Parameters:
4138 
     - collectedAmountMap
4139 
     - xferBy
4140 
     - xferTxnId
4141 
     - xferDate
4142 
    """
4143 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4144 
    return self.recv_reconcileCodCollection()
4145 
 
4146 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4147 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4148 
    args = reconcileCodCollection_args()
4149 
    args.collectedAmountMap = collectedAmountMap
4150 
    args.xferBy = xferBy
4151 
    args.xferTxnId = xferTxnId
4152 
    args.xferDate = xferDate
4153 
    args.write(self._oprot)
4154 
    self._oprot.writeMessageEnd()
4155 
    self._oprot.trans.flush()
4156 
 
4157 
  def recv_reconcileCodCollection(self, ):
4158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4159 
    if mtype == TMessageType.EXCEPTION:
4160 
      x = TApplicationException()
4161 
      x.read(self._iprot)
4162 
      self._iprot.readMessageEnd()
4163 
      raise x
4164 
    result = reconcileCodCollection_result()
4165 
    result.read(self._iprot)
4166 
    self._iprot.readMessageEnd()
4167 
    if result.success is not None:
4168 
      return result.success
4169 
    if result.ex is not None:
4170 
      raise result.ex
4171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4172 
 
4008 mandeep.dh 4173 
  def getTransactionsRequiringExtraProcessing(self, category):
4174 
    """
4065 mandeep.dh 4175 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4176 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4177 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4178 
 
4008 mandeep.dh 4179 
    Parameters:
4180 
     - category
4181 
    """
4182 
    self.send_getTransactionsRequiringExtraProcessing(category)
4183 
    return self.recv_getTransactionsRequiringExtraProcessing()
4184 
 
4185 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4186 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4187 
    args = getTransactionsRequiringExtraProcessing_args()
4188 
    args.category = category
4189 
    args.write(self._oprot)
4190 
    self._oprot.writeMessageEnd()
4191 
    self._oprot.trans.flush()
4192 
 
4193 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4195 
    if mtype == TMessageType.EXCEPTION:
4196 
      x = TApplicationException()
4197 
      x.read(self._iprot)
4198 
      self._iprot.readMessageEnd()
4199 
      raise x
4200 
    result = getTransactionsRequiringExtraProcessing_result()
4201 
    result.read(self._iprot)
4202 
    self._iprot.readMessageEnd()
4203 
    if result.success is not None:
4204 
      return result.success
4205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4206 
 
4207 
  def markTransactionAsProcessed(self, transactionId, category):
4208 
    """
4209 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4210 
    It essentially deletes the transaction id record for a particular
4211 
    processing type category (if present) from DB.
4212 
    This is currently used by CRM application.
4008 mandeep.dh 4213 
 
4214 
    Parameters:
4215 
     - transactionId
4216 
     - category
4217 
    """
4218 
    self.send_markTransactionAsProcessed(transactionId, category)
4219 
    self.recv_markTransactionAsProcessed()
4220 
 
4221 
  def send_markTransactionAsProcessed(self, transactionId, category):
4222 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4223 
    args = markTransactionAsProcessed_args()
4224 
    args.transactionId = transactionId
4225 
    args.category = category
4226 
    args.write(self._oprot)
4227 
    self._oprot.writeMessageEnd()
4228 
    self._oprot.trans.flush()
4229 
 
4230 
  def recv_markTransactionAsProcessed(self, ):
4231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4232 
    if mtype == TMessageType.EXCEPTION:
4233 
      x = TApplicationException()
4234 
      x.read(self._iprot)
4235 
      self._iprot.readMessageEnd()
4236 
      raise x
4237 
    result = markTransactionAsProcessed_result()
4238 
    result.read(self._iprot)
4239 
    self._iprot.readMessageEnd()
4240 
    return
4241 
 
4018 chandransh 4242 
  def getItemWiseRiskyOrdersCount(self, ):
4243 
    """
4244 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4245 
    is defined as one whose shipping date is about to expire.
4246 
    """
4247 
    self.send_getItemWiseRiskyOrdersCount()
4248 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4249 
 
4018 chandransh 4250 
  def send_getItemWiseRiskyOrdersCount(self, ):
4251 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4252 
    args = getItemWiseRiskyOrdersCount_args()
4253 
    args.write(self._oprot)
4254 
    self._oprot.writeMessageEnd()
4255 
    self._oprot.trans.flush()
4256 
 
4257 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4259 
    if mtype == TMessageType.EXCEPTION:
4260 
      x = TApplicationException()
4261 
      x.read(self._iprot)
4262 
      self._iprot.readMessageEnd()
4263 
      raise x
4264 
    result = getItemWiseRiskyOrdersCount_result()
4265 
    result.read(self._iprot)
4266 
    self._iprot.readMessageEnd()
4267 
    if result.success is not None:
4268 
      return result.success
4269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4270 
 
4295 varun.gupt 4271 
  def getOrdersForItemIds(self, itemIds):
4272 
    """
4273 
    Returns a list of all orders which have items with given id
4274 
 
4275 
    Parameters:
4276 
     - itemIds
4277 
    """
4278 
    self.send_getOrdersForItemIds(itemIds)
4279 
    return self.recv_getOrdersForItemIds()
4280 
 
4281 
  def send_getOrdersForItemIds(self, itemIds):
4282 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4283 
    args = getOrdersForItemIds_args()
4284 
    args.itemIds = itemIds
4285 
    args.write(self._oprot)
4286 
    self._oprot.writeMessageEnd()
4287 
    self._oprot.trans.flush()
4288 
 
4289 
  def recv_getOrdersForItemIds(self, ):
4290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4291 
    if mtype == TMessageType.EXCEPTION:
4292 
      x = TApplicationException()
4293 
      x.read(self._iprot)
4294 
      self._iprot.readMessageEnd()
4295 
      raise x
4296 
    result = getOrdersForItemIds_result()
4297 
    result.read(self._iprot)
4298 
    self._iprot.readMessageEnd()
4299 
    if result.success is not None:
4300 
      return result.success
4301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4302 
 
4247 rajveer 4303 
  def markOrderCancellationRequestReceived(self, orderId):
4304 
    """
4305 
    Mark order as cancellation request received. If customer sends request of cancellation of
4306 
    a particular order, this method will be called. It will just change status of the order
4307 
    depending on its current status. It also records the previous status, so that we can move
4308 
    back to that status if cancellation request is denied.
4018 chandransh 4309 
 
4247 rajveer 4310 
    Parameters:
4311 
     - orderId
4312 
    """
4313 
    self.send_markOrderCancellationRequestReceived(orderId)
4314 
    self.recv_markOrderCancellationRequestReceived()
4315 
 
4316 
  def send_markOrderCancellationRequestReceived(self, orderId):
4317 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4318 
    args = markOrderCancellationRequestReceived_args()
4319 
    args.orderId = orderId
4320 
    args.write(self._oprot)
4321 
    self._oprot.writeMessageEnd()
4322 
    self._oprot.trans.flush()
4323 
 
4324 
  def recv_markOrderCancellationRequestReceived(self, ):
4325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4326 
    if mtype == TMessageType.EXCEPTION:
4327 
      x = TApplicationException()
4328 
      x.read(self._iprot)
4329 
      self._iprot.readMessageEnd()
4330 
      raise x
4331 
    result = markOrderCancellationRequestReceived_result()
4332 
    result.read(self._iprot)
4333 
    self._iprot.readMessageEnd()
4334 
    if result.ex is not None:
4335 
      raise result.ex
4336 
    return
4337 
 
4338 
  def markOrderCancellationRequestConfirmed(self, orderId):
4339 
    """
4340 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4341 
    cancellation request confirmed. After this OM will be able to cancel the order.
4342 
 
4343 
    Parameters:
4344 
     - orderId
4345 
    """
4346 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4347 
    self.recv_markOrderCancellationRequestConfirmed()
4348 
 
4349 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4350 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4351 
    args = markOrderCancellationRequestConfirmed_args()
4352 
    args.orderId = orderId
4353 
    args.write(self._oprot)
4354 
    self._oprot.writeMessageEnd()
4355 
    self._oprot.trans.flush()
4356 
 
4357 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4359 
    if mtype == TMessageType.EXCEPTION:
4360 
      x = TApplicationException()
4361 
      x.read(self._iprot)
4362 
      self._iprot.readMessageEnd()
4363 
      raise x
4364 
    result = markOrderCancellationRequestConfirmed_result()
4365 
    result.read(self._iprot)
4366 
    self._iprot.readMessageEnd()
4367 
    if result.ex is not None:
4368 
      raise result.ex
4369 
    return
4370 
 
4371 
  def markOrderCancellationRequestDenied(self, orderId):
4372 
    """
4373 
    If we decide to not to cancel order, we will move the order ro previous status.
4374 
 
4375 
    Parameters:
4376 
     - orderId
4377 
    """
4378 
    self.send_markOrderCancellationRequestDenied(orderId)
4379 
    self.recv_markOrderCancellationRequestDenied()
4380 
 
4381 
  def send_markOrderCancellationRequestDenied(self, orderId):
4382 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4383 
    args = markOrderCancellationRequestDenied_args()
4384 
    args.orderId = orderId
4385 
    args.write(self._oprot)
4386 
    self._oprot.writeMessageEnd()
4387 
    self._oprot.trans.flush()
4388 
 
4389 
  def recv_markOrderCancellationRequestDenied(self, ):
4390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4391 
    if mtype == TMessageType.EXCEPTION:
4392 
      x = TApplicationException()
4393 
      x.read(self._iprot)
4394 
      self._iprot.readMessageEnd()
4395 
      raise x
4396 
    result = markOrderCancellationRequestDenied_result()
4397 
    result.read(self._iprot)
4398 
    self._iprot.readMessageEnd()
4399 
    if result.ex is not None:
4400 
      raise result.ex
4401 
    return
4402 
 
4258 rajveer 4403 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4404 
    """
4258 rajveer 4405 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4406 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4407 
 
4408 
    Parameters:
4258 rajveer 4409 
     - transactionId
4247 rajveer 4410 
    """
4258 rajveer 4411 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4412 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4413 
 
4258 rajveer 4414 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4415 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4416 
    args = markTransactionAsPaymentFlagRemoved_args()
4417 
    args.transactionId = transactionId
4247 rajveer 4418 
    args.write(self._oprot)
4419 
    self._oprot.writeMessageEnd()
4420 
    self._oprot.trans.flush()
4421 
 
4258 rajveer 4422 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4424 
    if mtype == TMessageType.EXCEPTION:
4425 
      x = TApplicationException()
4426 
      x.read(self._iprot)
4427 
      self._iprot.readMessageEnd()
4428 
      raise x
4258 rajveer 4429 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4430 
    result.read(self._iprot)
4431 
    self._iprot.readMessageEnd()
4432 
    if result.ex is not None:
4433 
      raise result.ex
4434 
    return
4435 
 
4259 anupam.sin 4436 
  def refundTransaction(self, transactionId, refundedBy, reason):
4437 
    """
4438 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4439 
    need to be cancelled
4247 rajveer 4440 
 
4259 anupam.sin 4441 
    Parameters:
4442 
     - transactionId
4443 
     - refundedBy
4444 
     - reason
4445 
    """
4446 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4447 
    self.recv_refundTransaction()
4448 
 
4449 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4450 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4451 
    args = refundTransaction_args()
4452 
    args.transactionId = transactionId
4453 
    args.refundedBy = refundedBy
4454 
    args.reason = reason
4455 
    args.write(self._oprot)
4456 
    self._oprot.writeMessageEnd()
4457 
    self._oprot.trans.flush()
4458 
 
4459 
  def recv_refundTransaction(self, ):
4460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4461 
    if mtype == TMessageType.EXCEPTION:
4462 
      x = TApplicationException()
4463 
      x.read(self._iprot)
4464 
      self._iprot.readMessageEnd()
4465 
      raise x
4466 
    result = refundTransaction_result()
4467 
    result.read(self._iprot)
4468 
    self._iprot.readMessageEnd()
4469 
    if result.ex is not None:
4470 
      raise result.ex
4471 
    return
4472 
 
4324 mandeep.dh 4473 
  def updateShipmentAddress(self, orderId, addressId):
4474 
    """
4475 
    Updates shipment address of an order. Delivery and shipping date estimates
4476 
    etc. are also updated here.
4477 
 
4478 
    Throws TransactionServiceException in case address change is not
4479 
    possible due to certain reasons such as new pincode in address is
4480 
    not serviceable etc.
4481 
 
4482 
    Parameters:
4483 
     - orderId
4484 
     - addressId
4485 
    """
4486 
    self.send_updateShipmentAddress(orderId, addressId)
4487 
    self.recv_updateShipmentAddress()
4488 
 
4489 
  def send_updateShipmentAddress(self, orderId, addressId):
4490 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4491 
    args = updateShipmentAddress_args()
4492 
    args.orderId = orderId
4493 
    args.addressId = addressId
4494 
    args.write(self._oprot)
4495 
    self._oprot.writeMessageEnd()
4496 
    self._oprot.trans.flush()
4497 
 
4498 
  def recv_updateShipmentAddress(self, ):
4499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4500 
    if mtype == TMessageType.EXCEPTION:
4501 
      x = TApplicationException()
4502 
      x.read(self._iprot)
4503 
      self._iprot.readMessageEnd()
4504 
      raise x
4505 
    result = updateShipmentAddress_result()
4506 
    result.read(self._iprot)
4507 
    self._iprot.readMessageEnd()
4508 
    if result.ex is not None:
4509 
      raise result.ex
4510 
    return
4511 
 
4285 rajveer 4512 
  def acceptOrdersForItemId(self, itemId, inventory):
4513 
    """
4514 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4515 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4516 
 
4285 rajveer 4517 
    Parameters:
4518 
     - itemId
4519 
     - inventory
4520 
    """
4521 
    self.send_acceptOrdersForItemId(itemId, inventory)
4522 
    return self.recv_acceptOrdersForItemId()
4523 
 
4524 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4525 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4526 
    args = acceptOrdersForItemId_args()
4527 
    args.itemId = itemId
4528 
    args.inventory = inventory
4529 
    args.write(self._oprot)
4530 
    self._oprot.writeMessageEnd()
4531 
    self._oprot.trans.flush()
4532 
 
4533 
  def recv_acceptOrdersForItemId(self, ):
4534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4535 
    if mtype == TMessageType.EXCEPTION:
4536 
      x = TApplicationException()
4537 
      x.read(self._iprot)
4538 
      self._iprot.readMessageEnd()
4539 
      raise x
4540 
    result = acceptOrdersForItemId_result()
4541 
    result.read(self._iprot)
4542 
    self._iprot.readMessageEnd()
4543 
    if result.success is not None:
4544 
      return result.success
4545 
    if result.ex is not None:
4546 
      raise result.ex
4547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4548 
 
4369 rajveer 4549 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4550 
    """
4551 
    Parameters:
4552 
     - vendorId
4553 
     - itemId
4554 
     - quantity
4555 
     - estimate
4369 rajveer 4556 
     - isReminder
4303 rajveer 4557 
    """
4369 rajveer 4558 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4559 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4560 
 
4369 rajveer 4561 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4562 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4563 
    args = markOrdersAsPORaised_args()
4564 
    args.vendorId = vendorId
4565 
    args.itemId = itemId
4566 
    args.quantity = quantity
4567 
    args.estimate = estimate
4369 rajveer 4568 
    args.isReminder = isReminder
4303 rajveer 4569 
    args.write(self._oprot)
4570 
    self._oprot.writeMessageEnd()
4571 
    self._oprot.trans.flush()
4572 
 
4573 
  def recv_markOrdersAsPORaised(self, ):
4574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4575 
    if mtype == TMessageType.EXCEPTION:
4576 
      x = TApplicationException()
4577 
      x.read(self._iprot)
4578 
      self._iprot.readMessageEnd()
4579 
      raise x
4580 
    result = markOrdersAsPORaised_result()
4581 
    result.read(self._iprot)
4582 
    self._iprot.readMessageEnd()
4583 
    if result.ex is not None:
4584 
      raise result.ex
4585 
    return
4586 
 
4369 rajveer 4587 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4588 
    """
4589 
    Parameters:
4590 
     - vendorId
4591 
     - itemId
4592 
     - quantity
4593 
     - estimate
4369 rajveer 4594 
     - isReminder
4303 rajveer 4595 
    """
4369 rajveer 4596 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4597 
    self.recv_markOrdersAsReversalInitiated()
4598 
 
4369 rajveer 4599 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4600 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4601 
    args = markOrdersAsReversalInitiated_args()
4602 
    args.vendorId = vendorId
4603 
    args.itemId = itemId
4604 
    args.quantity = quantity
4605 
    args.estimate = estimate
4369 rajveer 4606 
    args.isReminder = isReminder
4303 rajveer 4607 
    args.write(self._oprot)
4608 
    self._oprot.writeMessageEnd()
4609 
    self._oprot.trans.flush()
4610 
 
4611 
  def recv_markOrdersAsReversalInitiated(self, ):
4612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4613 
    if mtype == TMessageType.EXCEPTION:
4614 
      x = TApplicationException()
4615 
      x.read(self._iprot)
4616 
      self._iprot.readMessageEnd()
4617 
      raise x
4618 
    result = markOrdersAsReversalInitiated_result()
4619 
    result.read(self._iprot)
4620 
    self._iprot.readMessageEnd()
4621 
    if result.ex is not None:
4622 
      raise result.ex
4623 
    return
4624 
 
4369 rajveer 4625 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4626 
    """
4627 
    Parameters:
4628 
     - vendorId
4629 
     - itemId
4630 
     - quantity
4631 
     - estimate
4369 rajveer 4632 
     - isReminder
4303 rajveer 4633 
    """
4369 rajveer 4634 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4635 
    self.recv_markOrdersAsNotAvailabke()
4636 
 
4369 rajveer 4637 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4638 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4639 
    args = markOrdersAsNotAvailabke_args()
4640 
    args.vendorId = vendorId
4641 
    args.itemId = itemId
4642 
    args.quantity = quantity
4643 
    args.estimate = estimate
4369 rajveer 4644 
    args.isReminder = isReminder
4303 rajveer 4645 
    args.write(self._oprot)
4646 
    self._oprot.writeMessageEnd()
4647 
    self._oprot.trans.flush()
4648 
 
4649 
  def recv_markOrdersAsNotAvailabke(self, ):
4650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4651 
    if mtype == TMessageType.EXCEPTION:
4652 
      x = TApplicationException()
4653 
      x.read(self._iprot)
4654 
      self._iprot.readMessageEnd()
4655 
      raise x
4656 
    result = markOrdersAsNotAvailabke_result()
4657 
    result.read(self._iprot)
4658 
    self._iprot.readMessageEnd()
4659 
    if result.ex is not None:
4660 
      raise result.ex
4661 
    return
4662 
 
4369 rajveer 4663 
  def markOrdersAsTimeout(self, vendorId):
4664 
    """
4665 
    Parameters:
4666 
     - vendorId
4667 
    """
4668 
    self.send_markOrdersAsTimeout(vendorId)
4669 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4670 
 
4369 rajveer 4671 
  def send_markOrdersAsTimeout(self, vendorId):
4672 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4673 
    args = markOrdersAsTimeout_args()
4674 
    args.vendorId = vendorId
4675 
    args.write(self._oprot)
4676 
    self._oprot.writeMessageEnd()
4677 
    self._oprot.trans.flush()
4678 
 
4679 
  def recv_markOrdersAsTimeout(self, ):
4680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4681 
    if mtype == TMessageType.EXCEPTION:
4682 
      x = TApplicationException()
4683 
      x.read(self._iprot)
4684 
      self._iprot.readMessageEnd()
4685 
      raise x
4686 
    result = markOrdersAsTimeout_result()
4687 
    result.read(self._iprot)
4688 
    self._iprot.readMessageEnd()
4689 
    if result.success is not None:
4690 
      return result.success
4691 
    if result.ex is not None:
4692 
      raise result.ex
4693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4694 
 
4662 rajveer 4695 
  def markOrderAsLostInTransit(self, orderId):
4696 
    """
4697 
    Mark order as LOST_IN_TRANSIT
4698 
 
4699 
    Parameters:
4700 
     - orderId
4701 
    """
4702 
    self.send_markOrderAsLostInTransit(orderId)
4703 
    return self.recv_markOrderAsLostInTransit()
4704 
 
4705 
  def send_markOrderAsLostInTransit(self, orderId):
4706 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4707 
    args = markOrderAsLostInTransit_args()
4708 
    args.orderId = orderId
4709 
    args.write(self._oprot)
4710 
    self._oprot.writeMessageEnd()
4711 
    self._oprot.trans.flush()
4712 
 
4713 
  def recv_markOrderAsLostInTransit(self, ):
4714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4715 
    if mtype == TMessageType.EXCEPTION:
4716 
      x = TApplicationException()
4717 
      x.read(self._iprot)
4718 
      self._iprot.readMessageEnd()
4719 
      raise x
4720 
    result = markOrderAsLostInTransit_result()
4721 
    result.read(self._iprot)
4722 
    self._iprot.readMessageEnd()
4723 
    if result.success is not None:
4724 
      return result.success
4725 
    if result.ex is not None:
4726 
      raise result.ex
4727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4728 
 
4386 anupam.sin 4729 
  def getOrderForAwb(self, awb):
4730 
    """
4731 
    Returns the order corresponding to an AWB number
4369 rajveer 4732 
 
4386 anupam.sin 4733 
    Parameters:
4734 
     - awb
4735 
    """
4736 
    self.send_getOrderForAwb(awb)
4737 
    return self.recv_getOrderForAwb()
4738 
 
4739 
  def send_getOrderForAwb(self, awb):
4740 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4741 
    args = getOrderForAwb_args()
4742 
    args.awb = awb
4743 
    args.write(self._oprot)
4744 
    self._oprot.writeMessageEnd()
4745 
    self._oprot.trans.flush()
4746 
 
4747 
  def recv_getOrderForAwb(self, ):
4748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4749 
    if mtype == TMessageType.EXCEPTION:
4750 
      x = TApplicationException()
4751 
      x.read(self._iprot)
4752 
      self._iprot.readMessageEnd()
4753 
      raise x
4754 
    result = getOrderForAwb_result()
4755 
    result.read(self._iprot)
4756 
    self._iprot.readMessageEnd()
4757 
    if result.success is not None:
4758 
      return result.success
4759 
    if result.ex is not None:
4760 
      raise result.ex
4761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4762 
 
4910 phani.kuma 4763 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4764 
    """
4910 phani.kuma 4765 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4766 
 
4506 phani.kuma 4767 
    Parameters:
4768 
     - logistics_provider_id
4910 phani.kuma 4769 
     - order_status_list
4506 phani.kuma 4770 
    """
4910 phani.kuma 4771 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4772 
    return self.recv_getOrdersForProviderForStatus()
4773 
 
4910 phani.kuma 4774 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4775 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4776 
    args = getOrdersForProviderForStatus_args()
4777 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4778 
    args.order_status_list = order_status_list
4506 phani.kuma 4779 
    args.write(self._oprot)
4780 
    self._oprot.writeMessageEnd()
4781 
    self._oprot.trans.flush()
4782 
 
4783 
  def recv_getOrdersForProviderForStatus(self, ):
4784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4785 
    if mtype == TMessageType.EXCEPTION:
4786 
      x = TApplicationException()
4787 
      x.read(self._iprot)
4788 
      self._iprot.readMessageEnd()
4789 
      raise x
4790 
    result = getOrdersForProviderForStatus_result()
4791 
    result.read(self._iprot)
4792 
    self._iprot.readMessageEnd()
4793 
    if result.success is not None:
4794 
      return result.success
4795 
    if result.ex is not None:
4796 
      raise result.ex
4797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4798 
 
4600 varun.gupt 4799 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4800 
    """
4801 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4802 
 
4600 varun.gupt 4803 
    Parameters:
4804 
     - vendorId
4805 
     - billingDateFrom
4806 
     - billingDateTo
4807 
    """
4808 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4809 
    return self.recv_getBilledOrdersForVendor()
4810 
 
4811 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4812 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4813 
    args = getBilledOrdersForVendor_args()
4814 
    args.vendorId = vendorId
4815 
    args.billingDateFrom = billingDateFrom
4816 
    args.billingDateTo = billingDateTo
4817 
    args.write(self._oprot)
4818 
    self._oprot.writeMessageEnd()
4819 
    self._oprot.trans.flush()
4820 
 
4821 
  def recv_getBilledOrdersForVendor(self, ):
4822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4823 
    if mtype == TMessageType.EXCEPTION:
4824 
      x = TApplicationException()
4825 
      x.read(self._iprot)
4826 
      self._iprot.readMessageEnd()
4827 
      raise x
4828 
    result = getBilledOrdersForVendor_result()
4829 
    result.read(self._iprot)
4830 
    self._iprot.readMessageEnd()
4831 
    if result.success is not None:
4832 
      return result.success
4833 
    if result.ex is not None:
4834 
      raise result.ex
4835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4836 
 
4607 rajveer 4837 
  def getSlippedSippingDateOrders(self, ):
4838 
    self.send_getSlippedSippingDateOrders()
4839 
    return self.recv_getSlippedSippingDateOrders()
4840 
 
4841 
  def send_getSlippedSippingDateOrders(self, ):
4842 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4843 
    args = getSlippedSippingDateOrders_args()
4844 
    args.write(self._oprot)
4845 
    self._oprot.writeMessageEnd()
4846 
    self._oprot.trans.flush()
4847 
 
4848 
  def recv_getSlippedSippingDateOrders(self, ):
4849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4850 
    if mtype == TMessageType.EXCEPTION:
4851 
      x = TApplicationException()
4852 
      x.read(self._iprot)
4853 
      self._iprot.readMessageEnd()
4854 
      raise x
4855 
    result = getSlippedSippingDateOrders_result()
4856 
    result.read(self._iprot)
4857 
    self._iprot.readMessageEnd()
4858 
    if result.success is not None:
4859 
      return result.success
4860 
    if result.ex is not None:
4861 
      raise result.ex
4862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4863 
 
4709 rajveer 4864 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4865 
    """
4866 
    Parameters:
4867 
     - cancelDateFrom
4868 
     - cancelDateTo
4869 
    """
4870 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4871 
    return self.recv_getCancelledOrders()
4872 
 
4873 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4874 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4875 
    args = getCancelledOrders_args()
4876 
    args.cancelDateFrom = cancelDateFrom
4877 
    args.cancelDateTo = cancelDateTo
4878 
    args.write(self._oprot)
4879 
    self._oprot.writeMessageEnd()
4880 
    self._oprot.trans.flush()
4881 
 
4882 
  def recv_getCancelledOrders(self, ):
4883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4884 
    if mtype == TMessageType.EXCEPTION:
4885 
      x = TApplicationException()
4886 
      x.read(self._iprot)
4887 
      self._iprot.readMessageEnd()
4888 
      raise x
4889 
    result = getCancelledOrders_result()
4890 
    result.read(self._iprot)
4891 
    self._iprot.readMessageEnd()
4892 
    if result.success is not None:
4893 
      return result.success
4894 
    if result.ex is not None:
4895 
      raise result.ex
4896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4897 
 
4600 varun.gupt 4898 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4899 
    """
4900 
    Parameters:
4901 
     - mapAWBAndAmount
4902 
    """
4903 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4904 
    self.recv_saveBluedartSettlements()
4905 
 
4906 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4907 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4908 
    args = saveBluedartSettlements_args()
4909 
    args.mapAWBAndAmount = mapAWBAndAmount
4910 
    args.write(self._oprot)
4911 
    self._oprot.writeMessageEnd()
4912 
    self._oprot.trans.flush()
4913 
 
4914 
  def recv_saveBluedartSettlements(self, ):
4915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4916 
    if mtype == TMessageType.EXCEPTION:
4917 
      x = TApplicationException()
4918 
      x.read(self._iprot)
4919 
      self._iprot.readMessageEnd()
4920 
      raise x
4921 
    result = saveBluedartSettlements_result()
4922 
    result.read(self._iprot)
4923 
    self._iprot.readMessageEnd()
4924 
    if result.ex is not None:
4925 
      raise result.ex
4926 
    return
4927 
 
4905 varun.gupt 4928 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4929 
    """
4930 
    Parameters:
4931 
     - settlementDate
4932 
     - paymentGatewayId
4905 varun.gupt 4933 
     - referenceId
4600 varun.gupt 4934 
     - serviceTax
4935 
     - otherCharges
4936 
     - netCollection
4937 
    """
4905 varun.gupt 4938 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4939 
    self.recv_savePaymentSettlements()
4940 
 
4905 varun.gupt 4941 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4942 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4943 
    args = savePaymentSettlements_args()
4944 
    args.settlementDate = settlementDate
4945 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4946 
    args.referenceId = referenceId
4600 varun.gupt 4947 
    args.serviceTax = serviceTax
4948 
    args.otherCharges = otherCharges
4949 
    args.netCollection = netCollection
4950 
    args.write(self._oprot)
4951 
    self._oprot.writeMessageEnd()
4952 
    self._oprot.trans.flush()
4953 
 
4954 
  def recv_savePaymentSettlements(self, ):
4955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4956 
    if mtype == TMessageType.EXCEPTION:
4957 
      x = TApplicationException()
4958 
      x.read(self._iprot)
4959 
      self._iprot.readMessageEnd()
4960 
      raise x
4961 
    result = savePaymentSettlements_result()
4962 
    result.read(self._iprot)
4963 
    self._iprot.readMessageEnd()
4964 
    if result.ex is not None:
4965 
      raise result.ex
4966 
    return
4967 
 
4968 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4969 
    """
4970 
    Parameters:
4971 
     - settlementId
4972 
     - settlementDate
4973 
     - transactionDateFrom
4974 
     - transactionDateTo
4975 
     - amount
4976 
    """
4977 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
4978 
    self.recv_saveEBSSettlementSummary()
4979 
 
4980 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
4981 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
4982 
    args = saveEBSSettlementSummary_args()
4983 
    args.settlementId = settlementId
4984 
    args.settlementDate = settlementDate
4985 
    args.transactionDateFrom = transactionDateFrom
4986 
    args.transactionDateTo = transactionDateTo
4987 
    args.amount = amount
4988 
    args.write(self._oprot)
4989 
    self._oprot.writeMessageEnd()
4990 
    self._oprot.trans.flush()
4991 
 
4992 
  def recv_saveEBSSettlementSummary(self, ):
4993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4994 
    if mtype == TMessageType.EXCEPTION:
4995 
      x = TApplicationException()
4996 
      x.read(self._iprot)
4997 
      self._iprot.readMessageEnd()
4998 
      raise x
4999 
    result = saveEBSSettlementSummary_result()
5000 
    result.read(self._iprot)
5001 
    self._iprot.readMessageEnd()
5002 
    if result.ex is not None:
5003 
      raise result.ex
5004 
    return
5005 
 
5386 phani.kuma 5006 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5007 
    """
5008 
    Parameters:
5189 varun.gupt 5009 
     - referenceId
5010 
     - isRefund
4600 varun.gupt 5011 
    """
5386 phani.kuma 5012 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5013 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5014 
 
5386 phani.kuma 5015 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5016 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5017 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5018 
    args.referenceId = referenceId
5019 
    args.isRefund = isRefund
4600 varun.gupt 5020 
    args.write(self._oprot)
5021 
    self._oprot.writeMessageEnd()
5022 
    self._oprot.trans.flush()
5023 
 
5386 phani.kuma 5024 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5026 
    if mtype == TMessageType.EXCEPTION:
5027 
      x = TApplicationException()
5028 
      x.read(self._iprot)
5029 
      self._iprot.readMessageEnd()
5030 
      raise x
5386 phani.kuma 5031 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5032 
    result.read(self._iprot)
5033 
    self._iprot.readMessageEnd()
5034 
    if result.success is not None:
5035 
      return result.success
5036 
    if result.ex is not None:
5037 
      raise result.ex
5386 phani.kuma 5038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5039 
 
5386 phani.kuma 5040 
  def getSettlementForCod(self, orderId, isRefund):
5041 
    """
5042 
    Parameters:
5043 
     - orderId
5044 
     - isRefund
5045 
    """
5046 
    self.send_getSettlementForCod(orderId, isRefund)
5047 
    return self.recv_getSettlementForCod()
5048 
 
5049 
  def send_getSettlementForCod(self, orderId, isRefund):
5050 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5051 
    args = getSettlementForCod_args()
5052 
    args.orderId = orderId
5053 
    args.isRefund = isRefund
5054 
    args.write(self._oprot)
5055 
    self._oprot.writeMessageEnd()
5056 
    self._oprot.trans.flush()
5057 
 
5058 
  def recv_getSettlementForCod(self, ):
5059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5060 
    if mtype == TMessageType.EXCEPTION:
5061 
      x = TApplicationException()
5062 
      x.read(self._iprot)
5063 
      self._iprot.readMessageEnd()
5064 
      raise x
5065 
    result = getSettlementForCod_result()
5066 
    result.read(self._iprot)
5067 
    self._iprot.readMessageEnd()
5068 
    if result.success is not None:
5069 
      return result.success
5070 
    if result.ex is not None:
5071 
      raise result.ex
5072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5073 
 
4600 varun.gupt 5074 
  def getEBSSettlementSummaries(self, ):
5075 
    self.send_getEBSSettlementSummaries()
5076 
    return self.recv_getEBSSettlementSummaries()
5077 
 
5078 
  def send_getEBSSettlementSummaries(self, ):
5079 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5080 
    args = getEBSSettlementSummaries_args()
5081 
    args.write(self._oprot)
5082 
    self._oprot.writeMessageEnd()
5083 
    self._oprot.trans.flush()
5084 
 
5085 
  def recv_getEBSSettlementSummaries(self, ):
5086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5087 
    if mtype == TMessageType.EXCEPTION:
5088 
      x = TApplicationException()
5089 
      x.read(self._iprot)
5090 
      self._iprot.readMessageEnd()
5091 
      raise x
5092 
    result = getEBSSettlementSummaries_result()
5093 
    result.read(self._iprot)
5094 
    self._iprot.readMessageEnd()
5095 
    if result.success is not None:
5096 
      return result.success
5097 
    if result.ex is not None:
5098 
      raise result.ex
5099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5100 
 
5101 
  def markEBSSettlementUploaded(self, settlementId):
5102 
    """
5103 
    Parameters:
5104 
     - settlementId
5105 
    """
5106 
    self.send_markEBSSettlementUploaded(settlementId)
5107 
    self.recv_markEBSSettlementUploaded()
5108 
 
5109 
  def send_markEBSSettlementUploaded(self, settlementId):
5110 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5111 
    args = markEBSSettlementUploaded_args()
5112 
    args.settlementId = settlementId
5113 
    args.write(self._oprot)
5114 
    self._oprot.writeMessageEnd()
5115 
    self._oprot.trans.flush()
5116 
 
5117 
  def recv_markEBSSettlementUploaded(self, ):
5118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5119 
    if mtype == TMessageType.EXCEPTION:
5120 
      x = TApplicationException()
5121 
      x.read(self._iprot)
5122 
      self._iprot.readMessageEnd()
5123 
      raise x
5124 
    result = markEBSSettlementUploaded_result()
5125 
    result.read(self._iprot)
5126 
    self._iprot.readMessageEnd()
5127 
    if result.ex is not None:
5128 
      raise result.ex
5129 
    return
5130 
 
5131 
  def getEBSSettlementDate(self, settlementId):
5132 
    """
5133 
    Parameters:
5134 
     - settlementId
5135 
    """
5136 
    self.send_getEBSSettlementDate(settlementId)
5137 
    return self.recv_getEBSSettlementDate()
5138 
 
5139 
  def send_getEBSSettlementDate(self, settlementId):
5140 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5141 
    args = getEBSSettlementDate_args()
5142 
    args.settlementId = settlementId
5143 
    args.write(self._oprot)
5144 
    self._oprot.writeMessageEnd()
5145 
    self._oprot.trans.flush()
5146 
 
5147 
  def recv_getEBSSettlementDate(self, ):
5148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5149 
    if mtype == TMessageType.EXCEPTION:
5150 
      x = TApplicationException()
5151 
      x.read(self._iprot)
5152 
      self._iprot.readMessageEnd()
5153 
      raise x
5154 
    result = getEBSSettlementDate_result()
5155 
    result.read(self._iprot)
5156 
    self._iprot.readMessageEnd()
5157 
    if result.success is not None:
5158 
      return result.success
5159 
    if result.ex is not None:
5160 
      raise result.ex
5161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5162 
 
4715 varun.gupt 5163 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5164 
    """
5165 
    Parameters:
5166 
     - settlementDateFrom
5167 
     - settlementDateTo
5168 
     - isRefund
5169 
    """
5170 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5171 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5172 
 
4715 varun.gupt 5173 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5174 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5175 
    args = getSettlementsByDate_args()
5176 
    args.settlementDateFrom = settlementDateFrom
5177 
    args.settlementDateTo = settlementDateTo
5178 
    args.isRefund = isRefund
5179 
    args.write(self._oprot)
5180 
    self._oprot.writeMessageEnd()
5181 
    self._oprot.trans.flush()
5182 
 
5183 
  def recv_getSettlementsByDate(self, ):
5184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5185 
    if mtype == TMessageType.EXCEPTION:
5186 
      x = TApplicationException()
5187 
      x.read(self._iprot)
5188 
      self._iprot.readMessageEnd()
5189 
      raise x
5190 
    result = getSettlementsByDate_result()
5191 
    result.read(self._iprot)
5192 
    self._iprot.readMessageEnd()
5193 
    if result.success is not None:
5194 
      return result.success
5195 
    if result.ex is not None:
5196 
      raise result.ex
5197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5198 
 
5199 
  def getReshippedOrderIds(self, orderIds):
5200 
    """
5201 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5202 
 
5203 
    Parameters:
5204 
     - orderIds
5205 
    """
5206 
    self.send_getReshippedOrderIds(orderIds)
5207 
    return self.recv_getReshippedOrderIds()
5208 
 
5209 
  def send_getReshippedOrderIds(self, orderIds):
5210 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5211 
    args = getReshippedOrderIds_args()
5212 
    args.orderIds = orderIds
5213 
    args.write(self._oprot)
5214 
    self._oprot.writeMessageEnd()
5215 
    self._oprot.trans.flush()
5216 
 
5217 
  def recv_getReshippedOrderIds(self, ):
5218 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5219 
    if mtype == TMessageType.EXCEPTION:
5220 
      x = TApplicationException()
5221 
      x.read(self._iprot)
5222 
      self._iprot.readMessageEnd()
5223 
      raise x
5224 
    result = getReshippedOrderIds_result()
5225 
    result.read(self._iprot)
5226 
    self._iprot.readMessageEnd()
5227 
    if result.success is not None:
5228 
      return result.success
5229 
    if result.ex is not None:
5230 
      raise result.ex
5231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5232 
 
5481 phani.kuma 5233 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5234 
    """
5235 
    Parameters:
5236 
     - vendorId
5481 phani.kuma 5237 
     - onlyVendorNotPaid
5238 
     - billingDateFrom
5239 
     - billingDateTo
4875 varun.gupt 5240 
    """
5481 phani.kuma 5241 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5242 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5243 
 
5481 phani.kuma 5244 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5245 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5246 
    args = getBilledOrders_args()
4875 varun.gupt 5247 
    args.vendorId = vendorId
5481 phani.kuma 5248 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5249 
    args.billingDateFrom = billingDateFrom
5250 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5251 
    args.write(self._oprot)
5252 
    self._oprot.writeMessageEnd()
5253 
    self._oprot.trans.flush()
5254 
 
5481 phani.kuma 5255 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5257 
    if mtype == TMessageType.EXCEPTION:
5258 
      x = TApplicationException()
5259 
      x.read(self._iprot)
5260 
      self._iprot.readMessageEnd()
5261 
      raise x
5481 phani.kuma 5262 
    result = getBilledOrders_result()
4875 varun.gupt 5263 
    result.read(self._iprot)
5264 
    self._iprot.readMessageEnd()
5265 
    if result.success is not None:
5266 
      return result.success
5267 
    if result.ex is not None:
5268 
      raise result.ex
5481 phani.kuma 5269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5270 
 
5031 varun.gupt 5271 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5272 
    """
5273 
    Parameters:
5274 
     - startDate
5275 
     - endDate
5276 
    """
5277 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5278 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5279 
 
5031 varun.gupt 5280 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5281 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5282 
    args = getStatusDistributionOfOrders_args()
5283 
    args.startDate = startDate
5284 
    args.endDate = endDate
5285 
    args.write(self._oprot)
5286 
    self._oprot.writeMessageEnd()
5287 
    self._oprot.trans.flush()
5288 
 
5289 
  def recv_getStatusDistributionOfOrders(self, ):
5290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5291 
    if mtype == TMessageType.EXCEPTION:
5292 
      x = TApplicationException()
5293 
      x.read(self._iprot)
5294 
      self._iprot.readMessageEnd()
5295 
      raise x
5296 
    result = getStatusDistributionOfOrders_result()
5297 
    result.read(self._iprot)
5298 
    self._iprot.readMessageEnd()
5299 
    if result.success is not None:
5300 
      return result.success
5301 
    if result.ex is not None:
5302 
      raise result.ex
5303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5304 
 
5067 varun.gupt 5305 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5306 
    """
5307 
    Parameters:
5308 
     - status
5309 
     - startDatetime
5310 
     - endDatetime
5311 
    """
5312 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5313 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5314 
 
5067 varun.gupt 5315 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5316 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5317 
    args = getOrderIdsForStatus_args()
5318 
    args.status = status
5319 
    args.startDatetime = startDatetime
5320 
    args.endDatetime = endDatetime
5321 
    args.write(self._oprot)
5322 
    self._oprot.writeMessageEnd()
5323 
    self._oprot.trans.flush()
5324 
 
5325 
  def recv_getOrderIdsForStatus(self, ):
5326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5327 
    if mtype == TMessageType.EXCEPTION:
5328 
      x = TApplicationException()
5329 
      x.read(self._iprot)
5330 
      self._iprot.readMessageEnd()
5331 
      raise x
5332 
    result = getOrderIdsForStatus_result()
5333 
    result.read(self._iprot)
5334 
    self._iprot.readMessageEnd()
5335 
    if result.success is not None:
5336 
      return result.success
5337 
    if result.ex is not None:
5338 
      raise result.ex
5339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5340 
 
5348 anupam.sin 5341 
  def updateCODAgent(self, agent, orderId):
5342 
    """
5343 
    Updates the agent who handled the COD verification call
5344 
 
5345 
    Parameters:
5346 
     - agent
5347 
     - orderId
5348 
    """
5349 
    self.send_updateCODAgent(agent, orderId)
5350 
    self.recv_updateCODAgent()
5351 
 
5352 
  def send_updateCODAgent(self, agent, orderId):
5353 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5354 
    args = updateCODAgent_args()
5355 
    args.agent = agent
5356 
    args.orderId = orderId
5357 
    args.write(self._oprot)
5358 
    self._oprot.writeMessageEnd()
5359 
    self._oprot.trans.flush()
5360 
 
5361 
  def recv_updateCODAgent(self, ):
5362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5363 
    if mtype == TMessageType.EXCEPTION:
5364 
      x = TApplicationException()
5365 
      x.read(self._iprot)
5366 
      self._iprot.readMessageEnd()
5367 
      raise x
5368 
    result = updateCODAgent_result()
5369 
    result.read(self._iprot)
5370 
    self._iprot.readMessageEnd()
5371 
    if result.ex is not None:
5372 
      raise result.ex
5373 
    return
5374 
 
5099 varun.gupt 5375 
  def updateOrderAsPaidToVendor(self, orderId):
5376 
    """
5377 
    Parameters:
5378 
     - orderId
5379 
    """
5380 
    self.send_updateOrderAsPaidToVendor(orderId)
5381 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5382 
 
5099 varun.gupt 5383 
  def send_updateOrderAsPaidToVendor(self, orderId):
5384 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5385 
    args = updateOrderAsPaidToVendor_args()
5386 
    args.orderId = orderId
5387 
    args.write(self._oprot)
5388 
    self._oprot.writeMessageEnd()
5389 
    self._oprot.trans.flush()
5390 
 
5391 
  def recv_updateOrderAsPaidToVendor(self, ):
5392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5393 
    if mtype == TMessageType.EXCEPTION:
5394 
      x = TApplicationException()
5395 
      x.read(self._iprot)
5396 
      self._iprot.readMessageEnd()
5397 
      raise x
5398 
    result = updateOrderAsPaidToVendor_result()
5399 
    result.read(self._iprot)
5400 
    self._iprot.readMessageEnd()
5401 
    if result.ex is not None:
5402 
      raise result.ex
5403 
    return
5404 
 
5386 phani.kuma 5405 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5406 
    """
5407 
    Parameters:
5408 
     - orderId
5409 
    """
5410 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5411 
    self.recv_updateOrderOnlyAsPaidToVendor()
5412 
 
5413 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5414 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5415 
    args = updateOrderOnlyAsPaidToVendor_args()
5416 
    args.orderId = orderId
5417 
    args.write(self._oprot)
5418 
    self._oprot.writeMessageEnd()
5419 
    self._oprot.trans.flush()
5420 
 
5421 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5423 
    if mtype == TMessageType.EXCEPTION:
5424 
      x = TApplicationException()
5425 
      x.read(self._iprot)
5426 
      self._iprot.readMessageEnd()
5427 
      raise x
5428 
    result = updateOrderOnlyAsPaidToVendor_result()
5429 
    result.read(self._iprot)
5430 
    self._iprot.readMessageEnd()
5431 
    if result.ex is not None:
5432 
      raise result.ex
5433 
    return
5434 
 
5208 varun.gupt 5435 
  def getRefundedOrdersMarkedPaid(self, ):
5436 
    self.send_getRefundedOrdersMarkedPaid()
5437 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5438 
 
5208 varun.gupt 5439 
  def send_getRefundedOrdersMarkedPaid(self, ):
5440 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5441 
    args = getRefundedOrdersMarkedPaid_args()
5442 
    args.write(self._oprot)
5443 
    self._oprot.writeMessageEnd()
5444 
    self._oprot.trans.flush()
5445 
 
5446 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5448 
    if mtype == TMessageType.EXCEPTION:
5449 
      x = TApplicationException()
5450 
      x.read(self._iprot)
5451 
      self._iprot.readMessageEnd()
5452 
      raise x
5453 
    result = getRefundedOrdersMarkedPaid_result()
5454 
    result.read(self._iprot)
5455 
    self._iprot.readMessageEnd()
5456 
    if result.success is not None:
5457 
      return result.success
5458 
    if result.ex is not None:
5459 
      raise result.ex
5460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5461 
 
5447 anupam.sin 5462 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5463 
    """
5464 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5465 
 
5447 anupam.sin 5466 
 
5467 
    Parameters:
5468 
     - minOrderId
5469 
     - maxOrderId
5470 
    """
5471 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5472 
    return self.recv_getAllVerificationAgents()
5473 
 
5474 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5475 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5476 
    args = getAllVerificationAgents_args()
5477 
    args.minOrderId = minOrderId
5478 
    args.maxOrderId = maxOrderId
5479 
    args.write(self._oprot)
5480 
    self._oprot.writeMessageEnd()
5481 
    self._oprot.trans.flush()
5482 
 
5483 
  def recv_getAllVerificationAgents(self, ):
5484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5485 
    if mtype == TMessageType.EXCEPTION:
5486 
      x = TApplicationException()
5487 
      x.read(self._iprot)
5488 
      self._iprot.readMessageEnd()
5489 
      raise x
5490 
    result = getAllVerificationAgents_result()
5491 
    result.read(self._iprot)
5492 
    self._iprot.readMessageEnd()
5493 
    if result.success is not None:
5494 
      return result.success
5495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5496 
 
5527 anupam.sin 5497 
  def getAllAttributesForOrderId(self, orderId):
5498 
    """
5499 
    gets all attributes for a given orderId
5447 anupam.sin 5500 
 
5527 anupam.sin 5501 
    Parameters:
5502 
     - orderId
5503 
    """
5504 
    self.send_getAllAttributesForOrderId(orderId)
5505 
    return self.recv_getAllAttributesForOrderId()
5506 
 
5507 
  def send_getAllAttributesForOrderId(self, orderId):
5508 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5509 
    args = getAllAttributesForOrderId_args()
5510 
    args.orderId = orderId
5511 
    args.write(self._oprot)
5512 
    self._oprot.writeMessageEnd()
5513 
    self._oprot.trans.flush()
5514 
 
5515 
  def recv_getAllAttributesForOrderId(self, ):
5516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5517 
    if mtype == TMessageType.EXCEPTION:
5518 
      x = TApplicationException()
5519 
      x.read(self._iprot)
5520 
      self._iprot.readMessageEnd()
5521 
      raise x
5522 
    result = getAllAttributesForOrderId_result()
5523 
    result.read(self._iprot)
5524 
    self._iprot.readMessageEnd()
5525 
    if result.success is not None:
5526 
      return result.success
5527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5528 
 
5676 rajveer 5529 
  def setOrderAttributes(self, orderId, attributes):
5530 
    """
5531 
    sets attributes for an order
5532 
 
5533 
    Parameters:
5534 
     - orderId
5535 
     - attributes
5536 
    """
5537 
    self.send_setOrderAttributes(orderId, attributes)
5538 
    self.recv_setOrderAttributes()
5539 
 
5540 
  def send_setOrderAttributes(self, orderId, attributes):
5541 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5542 
    args = setOrderAttributes_args()
5543 
    args.orderId = orderId
5544 
    args.attributes = attributes
5545 
    args.write(self._oprot)
5546 
    self._oprot.writeMessageEnd()
5547 
    self._oprot.trans.flush()
5548 
 
5549 
  def recv_setOrderAttributes(self, ):
5550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5551 
    if mtype == TMessageType.EXCEPTION:
5552 
      x = TApplicationException()
5553 
      x.read(self._iprot)
5554 
      self._iprot.readMessageEnd()
5555 
      raise x
5556 
    result = setOrderAttributes_result()
5557 
    result.read(self._iprot)
5558 
    self._iprot.readMessageEnd()
5559 
    return
5560 
 
5527 anupam.sin 5561 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5562 
    """
5563 
    sets attributes for all orders in a transaction
5564 
 
5565 
    Parameters:
5566 
     - transactionId
5567 
     - attribute
5568 
    """
5569 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5570 
    self.recv_setOrderAttributeForTransaction()
5571 
 
5572 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5573 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5574 
    args = setOrderAttributeForTransaction_args()
5575 
    args.transactionId = transactionId
5576 
    args.attribute = attribute
5577 
    args.write(self._oprot)
5578 
    self._oprot.writeMessageEnd()
5579 
    self._oprot.trans.flush()
5580 
 
5581 
  def recv_setOrderAttributeForTransaction(self, ):
5582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5583 
    if mtype == TMessageType.EXCEPTION:
5584 
      x = TApplicationException()
5585 
      x.read(self._iprot)
5586 
      self._iprot.readMessageEnd()
5587 
      raise x
5588 
    result = setOrderAttributeForTransaction_result()
5589 
    result.read(self._iprot)
5590 
    self._iprot.readMessageEnd()
5591 
    return
5592 
 
5553 rajveer 5593 
  def getReceivePendingOrders(self, storeId):
5594 
    """
5595 
    Parameters:
5596 
     - storeId
5597 
    """
5598 
    self.send_getReceivePendingOrders(storeId)
5599 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5600 
 
5553 rajveer 5601 
  def send_getReceivePendingOrders(self, storeId):
5602 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5603 
    args = getReceivePendingOrders_args()
5604 
    args.storeId = storeId
5605 
    args.write(self._oprot)
5606 
    self._oprot.writeMessageEnd()
5607 
    self._oprot.trans.flush()
5608 
 
5609 
  def recv_getReceivePendingOrders(self, ):
5610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5611 
    if mtype == TMessageType.EXCEPTION:
5612 
      x = TApplicationException()
5613 
      x.read(self._iprot)
5614 
      self._iprot.readMessageEnd()
5615 
      raise x
5616 
    result = getReceivePendingOrders_result()
5617 
    result.read(self._iprot)
5618 
    self._iprot.readMessageEnd()
5619 
    if result.success is not None:
5620 
      return result.success
5621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5622 
 
5623 
  def getReceivedAtStoreOrders(self, storeId):
5624 
    """
5625 
    Parameters:
5626 
     - storeId
5627 
    """
5628 
    self.send_getReceivedAtStoreOrders(storeId)
5629 
    return self.recv_getReceivedAtStoreOrders()
5630 
 
5631 
  def send_getReceivedAtStoreOrders(self, storeId):
5632 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5633 
    args = getReceivedAtStoreOrders_args()
5634 
    args.storeId = storeId
5635 
    args.write(self._oprot)
5636 
    self._oprot.writeMessageEnd()
5637 
    self._oprot.trans.flush()
5638 
 
5639 
  def recv_getReceivedAtStoreOrders(self, ):
5640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5641 
    if mtype == TMessageType.EXCEPTION:
5642 
      x = TApplicationException()
5643 
      x.read(self._iprot)
5644 
      self._iprot.readMessageEnd()
5645 
      raise x
5646 
    result = getReceivedAtStoreOrders_result()
5647 
    result.read(self._iprot)
5648 
    self._iprot.readMessageEnd()
5649 
    if result.success is not None:
5650 
      return result.success
5651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5652 
 
5713 rajveer 5653 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5654 
    """
5655 
    Parameters:
5656 
     - storeId
5657 
     - fromDate
5658 
     - toDate
5659 
     - onlyCod
5660 
    """
5661 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5662 
    return self.recv_getOrdersCollectionAtStore()
5663 
 
5664 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5665 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5666 
    args = getOrdersCollectionAtStore_args()
5667 
    args.storeId = storeId
5668 
    args.fromDate = fromDate
5669 
    args.toDate = toDate
5670 
    args.onlyCod = onlyCod
5671 
    args.write(self._oprot)
5672 
    self._oprot.writeMessageEnd()
5673 
    self._oprot.trans.flush()
5674 
 
5675 
  def recv_getOrdersCollectionAtStore(self, ):
5676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5677 
    if mtype == TMessageType.EXCEPTION:
5678 
      x = TApplicationException()
5679 
      x.read(self._iprot)
5680 
      self._iprot.readMessageEnd()
5681 
      raise x
5682 
    result = getOrdersCollectionAtStore_result()
5683 
    result.read(self._iprot)
5684 
    self._iprot.readMessageEnd()
5685 
    if result.success is not None:
5686 
      return result.success
5687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5688 
 
5833 rajveer 5689 
  def getOrderAttributeValue(self, orderId, attributeName):
5690 
    """
5691 
    Parameters:
5692 
     - orderId
5693 
     - attributeName
5694 
    """
5695 
    self.send_getOrderAttributeValue(orderId, attributeName)
5696 
    return self.recv_getOrderAttributeValue()
5697 
 
5698 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5699 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5700 
    args = getOrderAttributeValue_args()
5701 
    args.orderId = orderId
5702 
    args.attributeName = attributeName
5703 
    args.write(self._oprot)
5704 
    self._oprot.writeMessageEnd()
5705 
    self._oprot.trans.flush()
5706 
 
5707 
  def recv_getOrderAttributeValue(self, ):
5708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5709 
    if mtype == TMessageType.EXCEPTION:
5710 
      x = TApplicationException()
5711 
      x.read(self._iprot)
5712 
      self._iprot.readMessageEnd()
5713 
      raise x
5714 
    result = getOrderAttributeValue_result()
5715 
    result.read(self._iprot)
5716 
    self._iprot.readMessageEnd()
5717 
    if result.success is not None:
5718 
      return result.success
5719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5720 
 
6019 rajveer 5721 
  def changeJacketNumber(self, orderId, jacketNumber):
5722 
    """
5723 
    Parameters:
5724 
     - orderId
5725 
     - jacketNumber
5726 
    """
5727 
    self.send_changeJacketNumber(orderId, jacketNumber)
5728 
    return self.recv_changeJacketNumber()
5729 
 
5730 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5731 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5732 
    args = changeJacketNumber_args()
5733 
    args.orderId = orderId
5734 
    args.jacketNumber = jacketNumber
5735 
    args.write(self._oprot)
5736 
    self._oprot.writeMessageEnd()
5737 
    self._oprot.trans.flush()
5738 
 
5739 
  def recv_changeJacketNumber(self, ):
5740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5741 
    if mtype == TMessageType.EXCEPTION:
5742 
      x = TApplicationException()
5743 
      x.read(self._iprot)
5744 
      self._iprot.readMessageEnd()
5745 
      raise x
5746 
    result = changeJacketNumber_result()
5747 
    result.read(self._iprot)
5748 
    self._iprot.readMessageEnd()
5749 
    if result.success is not None:
5750 
      return result.success
5751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5752 
 
5753 
  def markOrderAsRtoInTransit(self, orderId):
5754 
    """
5755 
    Parameters:
5756 
     - orderId
5757 
    """
5758 
    self.send_markOrderAsRtoInTransit(orderId)
5759 
    return self.recv_markOrderAsRtoInTransit()
5760 
 
5761 
  def send_markOrderAsRtoInTransit(self, orderId):
5762 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5763 
    args = markOrderAsRtoInTransit_args()
5764 
    args.orderId = orderId
5765 
    args.write(self._oprot)
5766 
    self._oprot.writeMessageEnd()
5767 
    self._oprot.trans.flush()
5768 
 
5769 
  def recv_markOrderAsRtoInTransit(self, ):
5770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5771 
    if mtype == TMessageType.EXCEPTION:
5772 
      x = TApplicationException()
5773 
      x.read(self._iprot)
5774 
      self._iprot.readMessageEnd()
5775 
      raise x
5776 
    result = markOrderAsRtoInTransit_result()
5777 
    result.read(self._iprot)
5778 
    self._iprot.readMessageEnd()
5779 
    if result.success is not None:
5780 
      return result.success
5781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5782 
 
5593 mandeep.dh 5783 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5784 
    """
5785 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5786 
    invoked while scanning IN of items.
5553 rajveer 5787 
 
5593 mandeep.dh 5788 
    Parameters:
5789 
     - itemId
5790 
     - quantity
5791 
     - fulfilmentWarehouseId
5792 
     - billingWarehouseId
5793 
    """
5794 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5795 
    self.recv_acceptOrderForItem()
5796 
 
5797 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5798 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5799 
    args = acceptOrderForItem_args()
5800 
    args.itemId = itemId
5801 
    args.quantity = quantity
5802 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5803 
    args.billingWarehouseId = billingWarehouseId
5804 
    args.write(self._oprot)
5805 
    self._oprot.writeMessageEnd()
5806 
    self._oprot.trans.flush()
5807 
 
5808 
  def recv_acceptOrderForItem(self, ):
5809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5810 
    if mtype == TMessageType.EXCEPTION:
5811 
      x = TApplicationException()
5812 
      x.read(self._iprot)
5813 
      self._iprot.readMessageEnd()
5814 
      raise x
5815 
    result = acceptOrderForItem_result()
5816 
    result.read(self._iprot)
5817 
    self._iprot.readMessageEnd()
5818 
    return
5819 
 
6000 mandeep.dh 5820 
  def createRechargeOrder(self, rechargeOrder):
5821 
    """
5822 
    Parameters:
5823 
     - rechargeOrder
5824 
    """
5825 
    self.send_createRechargeOrder(rechargeOrder)
5826 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5827 
 
6000 mandeep.dh 5828 
  def send_createRechargeOrder(self, rechargeOrder):
5829 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5830 
    args = createRechargeOrder_args()
5831 
    args.rechargeOrder = rechargeOrder
5832 
    args.write(self._oprot)
5833 
    self._oprot.writeMessageEnd()
5834 
    self._oprot.trans.flush()
5835 
 
5836 
  def recv_createRechargeOrder(self, ):
5837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5838 
    if mtype == TMessageType.EXCEPTION:
5839 
      x = TApplicationException()
5840 
      x.read(self._iprot)
5841 
      self._iprot.readMessageEnd()
5842 
      raise x
5843 
    result = createRechargeOrder_result()
5844 
    result.read(self._iprot)
5845 
    self._iprot.readMessageEnd()
5846 
    if result.success is not None:
5847 
      return result.success
5848 
    if result.ex is not None:
5849 
      raise result.ex
5850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5851 
 
6031 rajveer 5852 
  def getRechargeOrder(self, rechargeRrderId):
5853 
    """
5854 
    Parameters:
5855 
     - rechargeRrderId
5856 
    """
5857 
    self.send_getRechargeOrder(rechargeRrderId)
5858 
    return self.recv_getRechargeOrder()
5859 
 
5860 
  def send_getRechargeOrder(self, rechargeRrderId):
5861 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5862 
    args = getRechargeOrder_args()
5863 
    args.rechargeRrderId = rechargeRrderId
5864 
    args.write(self._oprot)
5865 
    self._oprot.writeMessageEnd()
5866 
    self._oprot.trans.flush()
5867 
 
5868 
  def recv_getRechargeOrder(self, ):
5869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5870 
    if mtype == TMessageType.EXCEPTION:
5871 
      x = TApplicationException()
5872 
      x.read(self._iprot)
5873 
      self._iprot.readMessageEnd()
5874 
      raise x
5875 
    result = getRechargeOrder_result()
5876 
    result.read(self._iprot)
5877 
    self._iprot.readMessageEnd()
5878 
    if result.success is not None:
5879 
      return result.success
5880 
    if result.ex is not None:
5881 
      raise result.ex
5882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5883 
 
5884 
  def getRechargeOrders(self, userId):
5885 
    """
5886 
    Parameters:
5887 
     - userId
5888 
    """
5889 
    self.send_getRechargeOrders(userId)
5890 
    return self.recv_getRechargeOrders()
5891 
 
5892 
  def send_getRechargeOrders(self, userId):
5893 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5894 
    args = getRechargeOrders_args()
5895 
    args.userId = userId
5896 
    args.write(self._oprot)
5897 
    self._oprot.writeMessageEnd()
5898 
    self._oprot.trans.flush()
5899 
 
5900 
  def recv_getRechargeOrders(self, ):
5901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5902 
    if mtype == TMessageType.EXCEPTION:
5903 
      x = TApplicationException()
5904 
      x.read(self._iprot)
5905 
      self._iprot.readMessageEnd()
5906 
      raise x
5907 
    result = getRechargeOrders_result()
5908 
    result.read(self._iprot)
5909 
    self._iprot.readMessageEnd()
5910 
    if result.success is not None:
5911 
      return result.success
5912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5913 
 
6000 mandeep.dh 5914 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5915 
    """
5916 
    Parameters:
5917 
     - rechargeOrderId
5918 
     - rechargeOrderStatus
5919 
    """
5920 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5921 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5922 
 
5923 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5924 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5925 
    args = updateRechargeOrderStatus_args()
5926 
    args.rechargeOrderId = rechargeOrderId
5927 
    args.rechargeOrderStatus = rechargeOrderStatus
5928 
    args.write(self._oprot)
5929 
    self._oprot.writeMessageEnd()
5930 
    self._oprot.trans.flush()
5931 
 
5932 
  def recv_updateRechargeOrderStatus(self, ):
5933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5934 
    if mtype == TMessageType.EXCEPTION:
5935 
      x = TApplicationException()
5936 
      x.read(self._iprot)
5937 
      self._iprot.readMessageEnd()
5938 
      raise x
5939 
    result = updateRechargeOrderStatus_result()
5940 
    result.read(self._iprot)
5941 
    self._iprot.readMessageEnd()
6031 rajveer 5942 
    if result.success is not None:
5943 
      return result.success
6000 mandeep.dh 5944 
    if result.ex is not None:
5945 
      raise result.ex
6031 rajveer 5946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5947 
 
6031 rajveer 5948 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5949 
    """
5950 
    Parameters:
6031 rajveer 5951 
     - rechargeOrderId
6000 mandeep.dh 5952 
    """
6031 rajveer 5953 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5954 
    return self.recv_activateRechargeTxn()
5955 
 
6031 rajveer 5956 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5957 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5958 
    args = activateRechargeTxn_args()
6031 rajveer 5959 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5960 
    args.write(self._oprot)
5961 
    self._oprot.writeMessageEnd()
5962 
    self._oprot.trans.flush()
5963 
 
5964 
  def recv_activateRechargeTxn(self, ):
5965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5966 
    if mtype == TMessageType.EXCEPTION:
5967 
      x = TApplicationException()
5968 
      x.read(self._iprot)
5969 
      self._iprot.readMessageEnd()
5970 
      raise x
5971 
    result = activateRechargeTxn_result()
5972 
    result.read(self._iprot)
5973 
    self._iprot.readMessageEnd()
5974 
    if result.success is not None:
5975 
      return result.success
5976 
    if result.ex is not None:
5977 
      raise result.ex
5978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
5979 
 
6031 rajveer 5980 
  def getUserWallet(self, userId):
6000 mandeep.dh 5981 
    """
5982 
    Parameters:
6031 rajveer 5983 
     - userId
6000 mandeep.dh 5984 
    """
6031 rajveer 5985 
    self.send_getUserWallet(userId)
5986 
    return self.recv_getUserWallet()
6000 mandeep.dh 5987 
 
6031 rajveer 5988 
  def send_getUserWallet(self, userId):
5989 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
5990 
    args = getUserWallet_args()
5991 
    args.userId = userId
6000 mandeep.dh 5992 
    args.write(self._oprot)
5993 
    self._oprot.writeMessageEnd()
5994 
    self._oprot.trans.flush()
5995 
 
6031 rajveer 5996 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 5997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5998 
    if mtype == TMessageType.EXCEPTION:
5999 
      x = TApplicationException()
6000 
      x.read(self._iprot)
6001 
      self._iprot.readMessageEnd()
6002 
      raise x
6031 rajveer 6003 
    result = getUserWallet_result()
6000 mandeep.dh 6004 
    result.read(self._iprot)
6005 
    self._iprot.readMessageEnd()
6006 
    if result.success is not None:
6007 
      return result.success
6031 rajveer 6008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6009 
 
6031 rajveer 6010 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6011 
    """
6012 
    Parameters:
6031 rajveer 6013 
     - userId
6000 mandeep.dh 6014 
    """
6031 rajveer 6015 
    self.send_getUserWalletHistory(userId)
6016 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6017 
 
6031 rajveer 6018 
  def send_getUserWalletHistory(self, userId):
6019 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6020 
    args = getUserWalletHistory_args()
6021 
    args.userId = userId
6000 mandeep.dh 6022 
    args.write(self._oprot)
6023 
    self._oprot.writeMessageEnd()
6024 
    self._oprot.trans.flush()
6025 
 
6031 rajveer 6026 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6028 
    if mtype == TMessageType.EXCEPTION:
6029 
      x = TApplicationException()
6030 
      x.read(self._iprot)
6031 
      self._iprot.readMessageEnd()
6032 
      raise x
6031 rajveer 6033 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6034 
    result.read(self._iprot)
6035 
    self._iprot.readMessageEnd()
6036 
    if result.success is not None:
6037 
      return result.success
6031 rajveer 6038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6039 
 
6050 anupam.sin 6040 
  def getRechargeOrdersForTransaction(self, txnId):
6041 
    """
6042 
    Returns a recharge order for a given transactionId
6043 
 
6044 
    Parameters:
6045 
     - txnId
6046 
    """
6047 
    self.send_getRechargeOrdersForTransaction(txnId)
6048 
    return self.recv_getRechargeOrdersForTransaction()
6049 
 
6050 
  def send_getRechargeOrdersForTransaction(self, txnId):
6051 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6052 
    args = getRechargeOrdersForTransaction_args()
6053 
    args.txnId = txnId
6054 
    args.write(self._oprot)
6055 
    self._oprot.writeMessageEnd()
6056 
    self._oprot.trans.flush()
6057 
 
6058 
  def recv_getRechargeOrdersForTransaction(self, ):
6059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6060 
    if mtype == TMessageType.EXCEPTION:
6061 
      x = TApplicationException()
6062 
      x.read(self._iprot)
6063 
      self._iprot.readMessageEnd()
6064 
      raise x
6065 
    result = getRechargeOrdersForTransaction_result()
6066 
    result.read(self._iprot)
6067 
    self._iprot.readMessageEnd()
6068 
    if result.success is not None:
6069 
      return result.success
6070 
    if result.ex is not None:
6071 
      raise result.ex
6072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6073 
 
6048 rajveer 6074 
  def getServiceProviders(self, rechargeType):
6075 
    """
6076 
    Parameters:
6077 
     - rechargeType
6078 
    """
6079 
    self.send_getServiceProviders(rechargeType)
6080 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6081 
 
6048 rajveer 6082 
  def send_getServiceProviders(self, rechargeType):
6083 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6084 
    args = getServiceProviders_args()
6085 
    args.rechargeType = rechargeType
6086 
    args.write(self._oprot)
6087 
    self._oprot.writeMessageEnd()
6088 
    self._oprot.trans.flush()
6089 
 
6090 
  def recv_getServiceProviders(self, ):
6091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6092 
    if mtype == TMessageType.EXCEPTION:
6093 
      x = TApplicationException()
6094 
      x.read(self._iprot)
6095 
      self._iprot.readMessageEnd()
6096 
      raise x
6097 
    result = getServiceProviders_result()
6098 
    result.read(self._iprot)
6099 
    self._iprot.readMessageEnd()
6100 
    if result.success is not None:
6101 
      return result.success
6102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6103 
 
6049 rajveer 6104 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6105 
    """
6106 
    Parameters:
6049 rajveer 6107 
     - rechargeType
6048 rajveer 6108 
     - deviceNumber
6109 
    """
6049 rajveer 6110 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6111 
    return self.recv_getServiceProviderForDevice()
6112 
 
6049 rajveer 6113 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6114 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6115 
    args = getServiceProviderForDevice_args()
6049 rajveer 6116 
    args.rechargeType = rechargeType
6048 rajveer 6117 
    args.deviceNumber = deviceNumber
6118 
    args.write(self._oprot)
6119 
    self._oprot.writeMessageEnd()
6120 
    self._oprot.trans.flush()
6121 
 
6122 
  def recv_getServiceProviderForDevice(self, ):
6123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6124 
    if mtype == TMessageType.EXCEPTION:
6125 
      x = TApplicationException()
6126 
      x.read(self._iprot)
6127 
      self._iprot.readMessageEnd()
6128 
      raise x
6129 
    result = getServiceProviderForDevice_result()
6130 
    result.read(self._iprot)
6131 
    self._iprot.readMessageEnd()
6132 
    if result.success is not None:
6133 
      return result.success
6134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6135 
 
6094 rajveer 6136 
  def getRechargeOrdersForDevice(self, deviceNumber):
6137 
    """
6138 
    Parameters:
6139 
     - deviceNumber
6140 
    """
6141 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6142 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6143 
 
6094 rajveer 6144 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6145 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6146 
    args = getRechargeOrdersForDevice_args()
6147 
    args.deviceNumber = deviceNumber
6148 
    args.write(self._oprot)
6149 
    self._oprot.writeMessageEnd()
6150 
    self._oprot.trans.flush()
6151 
 
6152 
  def recv_getRechargeOrdersForDevice(self, ):
6153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6154 
    if mtype == TMessageType.EXCEPTION:
6155 
      x = TApplicationException()
6156 
      x.read(self._iprot)
6157 
      self._iprot.readMessageEnd()
6158 
      raise x
6159 
    result = getRechargeOrdersForDevice_result()
6160 
    result.read(self._iprot)
6161 
    self._iprot.readMessageEnd()
6162 
    if result.success is not None:
6163 
      return result.success
6164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6165 
 
6166 
  def addAmountToWallet(self, userId, orderId, amount):
6167 
    """
6168 
    Parameters:
6169 
     - userId
6170 
     - orderId
6171 
     - amount
6172 
    """
6173 
    self.send_addAmountToWallet(userId, orderId, amount)
6174 
    self.recv_addAmountToWallet()
6175 
 
6176 
  def send_addAmountToWallet(self, userId, orderId, amount):
6177 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6178 
    args = addAmountToWallet_args()
6179 
    args.userId = userId
6180 
    args.orderId = orderId
6181 
    args.amount = amount
6182 
    args.write(self._oprot)
6183 
    self._oprot.writeMessageEnd()
6184 
    self._oprot.trans.flush()
6185 
 
6186 
  def recv_addAmountToWallet(self, ):
6187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6188 
    if mtype == TMessageType.EXCEPTION:
6189 
      x = TApplicationException()
6190 
      x.read(self._iprot)
6191 
      self._iprot.readMessageEnd()
6192 
      raise x
6193 
    result = addAmountToWallet_result()
6194 
    result.read(self._iprot)
6195 
    self._iprot.readMessageEnd()
6196 
    return
6197 
 
6198 
 
3376 rajveer 6199 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6200 
  def __init__(self, handler):
3376 rajveer 6201 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6202 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6203 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6204 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6205 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6206 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6207 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6208 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6209 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6210 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6211 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6212 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6213 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6214 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6215 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6216 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6217 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6218 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6219 
    self._processMap["createOrder"] = Processor.process_createOrder
6220 
    self._processMap["getOrder"] = Processor.process_getOrder
6221 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6222 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6223 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6224 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6225 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6226 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6227 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6228 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6229 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6230 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6231 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6232 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6233 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6234 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6235 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6236 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6237 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6238 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6239 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6240 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6241 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6242 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6243 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6244 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6245 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6246 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6247 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6248 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6249 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6250 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6251 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6252 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6253 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6254 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6255 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6256 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6257 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6258 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6259 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6260 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6261 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6262 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6263 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6264 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6265 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6266 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6267 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6268 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6269 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6270 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6271 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6272 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6273 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6274 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6275 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6276 
    self._processMap["changeItem"] = Processor.process_changeItem
6277 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6278 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6279 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6280 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6281 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6282 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6283 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6284 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6285 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6286 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6287 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6288 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6289 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6290 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6291 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6292 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6293 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6294 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6295 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6296 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6297 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6298 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6299 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6300 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6301 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6302 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6303 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6304 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6305 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6306 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6307 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6308 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6309 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6310 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6311 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6312 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6313 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6314 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6315 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6316 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6317 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6318 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6319 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6320 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6321 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6322 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6323 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6324 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6325 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6326 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6327 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6328 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6329 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6330 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6331 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6332 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6333 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6334 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6335 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6336 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6337 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6338 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6094 rajveer 6339 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6340 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
94 ashish 6341 
 
6342 
  def process(self, iprot, oprot):
6343 
    (name, type, seqid) = iprot.readMessageBegin()
6344 
    if name not in self._processMap:
6345 
      iprot.skip(TType.STRUCT)
6346 
      iprot.readMessageEnd()
6347 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6348 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6349 
      x.write(oprot)
6350 
      oprot.writeMessageEnd()
6351 
      oprot.trans.flush()
6352 
      return
6353 
    else:
6354 
      self._processMap[name](self, seqid, iprot, oprot)
6355 
    return True
6356 
 
6357 
  def process_createTransaction(self, seqid, iprot, oprot):
6358 
    args = createTransaction_args()
6359 
    args.read(iprot)
6360 
    iprot.readMessageEnd()
6361 
    result = createTransaction_result()
6362 
    try:
132 ashish 6363 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6364 
    except TransactionServiceException, ex:
6365 
      result.ex = ex
6366 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6367 
    result.write(oprot)
6368 
    oprot.writeMessageEnd()
6369 
    oprot.trans.flush()
6370 
 
6371 
  def process_getTransaction(self, seqid, iprot, oprot):
6372 
    args = getTransaction_args()
6373 
    args.read(iprot)
6374 
    iprot.readMessageEnd()
6375 
    result = getTransaction_result()
6376 
    try:
6377 
      result.success = self._handler.getTransaction(args.id)
6378 
    except TransactionServiceException, ex:
6379 
      result.ex = ex
6380 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6381 
    result.write(oprot)
6382 
    oprot.writeMessageEnd()
6383 
    oprot.trans.flush()
6384 
 
6385 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6386 
    args = getTransactionsForCustomer_args()
6387 
    args.read(iprot)
6388 
    iprot.readMessageEnd()
6389 
    result = getTransactionsForCustomer_result()
6390 
    try:
6391 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6392 
    except TransactionServiceException, ex:
6393 
      result.ex = ex
6394 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6395 
    result.write(oprot)
6396 
    oprot.writeMessageEnd()
6397 
    oprot.trans.flush()
6398 
 
132 ashish 6399 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6400 
    args = getTransactionsForShoppingCartId_args()
6401 
    args.read(iprot)
6402 
    iprot.readMessageEnd()
6403 
    result = getTransactionsForShoppingCartId_result()
6404 
    try:
6405 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6406 
    except TransactionServiceException, ex:
6407 
      result.ex = ex
6408 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6409 
    result.write(oprot)
6410 
    oprot.writeMessageEnd()
6411 
    oprot.trans.flush()
6412 
 
94 ashish 6413 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6414 
    args = getTransactionStatus_args()
6415 
    args.read(iprot)
6416 
    iprot.readMessageEnd()
6417 
    result = getTransactionStatus_result()
6418 
    try:
6419 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6420 
    except TransactionServiceException, ex:
6421 
      result.ex = ex
6422 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6423 
    result.write(oprot)
6424 
    oprot.writeMessageEnd()
6425 
    oprot.trans.flush()
6426 
 
6427 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6428 
    args = changeTransactionStatus_args()
6429 
    args.read(iprot)
6430 
    iprot.readMessageEnd()
6431 
    result = changeTransactionStatus_result()
6432 
    try:
5527 anupam.sin 6433 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6434 
    except TransactionServiceException, ex:
6435 
      result.ex = ex
6436 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6437 
    result.write(oprot)
6438 
    oprot.writeMessageEnd()
6439 
    oprot.trans.flush()
6440 
 
1398 varun.gupt 6441 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6442 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6443 
    args.read(iprot)
6444 
    iprot.readMessageEnd()
1398 varun.gupt 6445 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6446 
    try:
1398 varun.gupt 6447 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6448 
    except TransactionServiceException, ex:
6449 
      result.ex = ex
1398 varun.gupt 6450 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6451 
    result.write(oprot)
6452 
    oprot.writeMessageEnd()
6453 
    oprot.trans.flush()
6454 
 
483 rajveer 6455 
  def process_getAllOrders(self, seqid, iprot, oprot):
6456 
    args = getAllOrders_args()
94 ashish 6457 
    args.read(iprot)
6458 
    iprot.readMessageEnd()
483 rajveer 6459 
    result = getAllOrders_result()
94 ashish 6460 
    try:
4801 anupam.sin 6461 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6462 
    except TransactionServiceException, ex:
6463 
      result.ex = ex
483 rajveer 6464 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6465 
    result.write(oprot)
6466 
    oprot.writeMessageEnd()
6467 
    oprot.trans.flush()
6468 
 
4133 chandransh 6469 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6470 
    args = getOrdersInBatch_args()
6471 
    args.read(iprot)
6472 
    iprot.readMessageEnd()
6473 
    result = getOrdersInBatch_result()
6474 
    try:
6475 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6476 
    except TransactionServiceException, ex:
6477 
      result.ex = ex
6478 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6479 
    result.write(oprot)
6480 
    oprot.writeMessageEnd()
6481 
    oprot.trans.flush()
6482 
 
6483 
  def process_getOrderCount(self, seqid, iprot, oprot):
6484 
    args = getOrderCount_args()
6485 
    args.read(iprot)
6486 
    iprot.readMessageEnd()
6487 
    result = getOrderCount_result()
6488 
    try:
6489 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6490 
    except TransactionServiceException, ex:
6491 
      result.ex = ex
6492 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6493 
    result.write(oprot)
6494 
    oprot.writeMessageEnd()
6495 
    oprot.trans.flush()
6496 
 
999 varun.gupt 6497 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6498 
    args = getOrdersByBillingDate_args()
6499 
    args.read(iprot)
6500 
    iprot.readMessageEnd()
6501 
    result = getOrdersByBillingDate_result()
6502 
    try:
6503 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6504 
    except TransactionServiceException, ex:
6505 
      result.ex = ex
6506 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6507 
    result.write(oprot)
6508 
    oprot.writeMessageEnd()
6509 
    oprot.trans.flush()
6510 
 
3427 chandransh 6511 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6512 
    args = getOrdersByShippingDate_args()
6513 
    args.read(iprot)
6514 
    iprot.readMessageEnd()
6515 
    result = getOrdersByShippingDate_result()
6516 
    try:
3451 chandransh 6517 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6518 
    except TransactionServiceException, ex:
6519 
      result.ex = ex
6520 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6521 
    result.write(oprot)
6522 
    oprot.writeMessageEnd()
6523 
    oprot.trans.flush()
6524 
 
1382 varun.gupt 6525 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6526 
    args = getReturnableOrdersForCustomer_args()
6527 
    args.read(iprot)
6528 
    iprot.readMessageEnd()
6529 
    result = getReturnableOrdersForCustomer_result()
6530 
    try:
6531 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6532 
    except TransactionServiceException, ex:
6533 
      result.ex = ex
6534 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6535 
    result.write(oprot)
6536 
    oprot.writeMessageEnd()
6537 
    oprot.trans.flush()
6538 
 
6539 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6540 
    args = getCancellableOrdersForCustomer_args()
6541 
    args.read(iprot)
6542 
    iprot.readMessageEnd()
6543 
    result = getCancellableOrdersForCustomer_result()
6544 
    try:
6545 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6546 
    except TransactionServiceException, ex:
6547 
      result.ex = ex
6548 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6549 
    result.write(oprot)
6550 
    oprot.writeMessageEnd()
6551 
    oprot.trans.flush()
6552 
 
483 rajveer 6553 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6554 
    args = changeOrderStatus_args()
94 ashish 6555 
    args.read(iprot)
6556 
    iprot.readMessageEnd()
483 rajveer 6557 
    result = changeOrderStatus_result()
94 ashish 6558 
    try:
483 rajveer 6559 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6560 
    except TransactionServiceException, ex:
6561 
      result.ex = ex
483 rajveer 6562 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6563 
    result.write(oprot)
6564 
    oprot.writeMessageEnd()
6565 
    oprot.trans.flush()
6566 
 
483 rajveer 6567 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6568 
    args = getOrdersForTransaction_args()
94 ashish 6569 
    args.read(iprot)
6570 
    iprot.readMessageEnd()
483 rajveer 6571 
    result = getOrdersForTransaction_result()
94 ashish 6572 
    try:
1528 ankur.sing 6573 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6574 
    except TransactionServiceException, ex:
6575 
      result.ex = ex
483 rajveer 6576 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6577 
    result.write(oprot)
6578 
    oprot.writeMessageEnd()
6579 
    oprot.trans.flush()
6580 
 
483 rajveer 6581 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6582 
    args = getOrdersForCustomer_args()
94 ashish 6583 
    args.read(iprot)
6584 
    iprot.readMessageEnd()
483 rajveer 6585 
    result = getOrdersForCustomer_result()
94 ashish 6586 
    try:
3014 chandransh 6587 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6588 
    except TransactionServiceException, ex:
6589 
      result.ex = ex
483 rajveer 6590 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6591 
    result.write(oprot)
6592 
    oprot.writeMessageEnd()
6593 
    oprot.trans.flush()
6594 
 
483 rajveer 6595 
  def process_createOrder(self, seqid, iprot, oprot):
6596 
    args = createOrder_args()
94 ashish 6597 
    args.read(iprot)
6598 
    iprot.readMessageEnd()
483 rajveer 6599 
    result = createOrder_result()
94 ashish 6600 
    try:
483 rajveer 6601 
      result.success = self._handler.createOrder(args.order)
94 ashish 6602 
    except TransactionServiceException, ex:
6603 
      result.ex = ex
483 rajveer 6604 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6605 
    result.write(oprot)
6606 
    oprot.writeMessageEnd()
6607 
    oprot.trans.flush()
6608 
 
483 rajveer 6609 
  def process_getOrder(self, seqid, iprot, oprot):
6610 
    args = getOrder_args()
94 ashish 6611 
    args.read(iprot)
6612 
    iprot.readMessageEnd()
483 rajveer 6613 
    result = getOrder_result()
94 ashish 6614 
    try:
483 rajveer 6615 
      result.success = self._handler.getOrder(args.id)
94 ashish 6616 
    except TransactionServiceException, ex:
6617 
      result.ex = ex
483 rajveer 6618 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6619 
    result.write(oprot)
6620 
    oprot.writeMessageEnd()
6621 
    oprot.trans.flush()
6622 
 
483 rajveer 6623 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6624 
    args = getLineItemsForOrder_args()
94 ashish 6625 
    args.read(iprot)
6626 
    iprot.readMessageEnd()
483 rajveer 6627 
    result = getLineItemsForOrder_result()
94 ashish 6628 
    try:
483 rajveer 6629 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6630 
    except TransactionServiceException, ex:
6631 
      result.ex = ex
483 rajveer 6632 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6633 
    result.write(oprot)
6634 
    oprot.writeMessageEnd()
6635 
    oprot.trans.flush()
6636 
 
4999 phani.kuma 6637 
  def process_getOrderList(self, seqid, iprot, oprot):
6638 
    args = getOrderList_args()
6639 
    args.read(iprot)
6640 
    iprot.readMessageEnd()
6641 
    result = getOrderList_result()
6642 
    result.success = self._handler.getOrderList(args.order_ids)
6643 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6644 
    result.write(oprot)
6645 
    oprot.writeMessageEnd()
6646 
    oprot.trans.flush()
6647 
 
5386 phani.kuma 6648 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6649 
    args = getOrderListForVendor_args()
6650 
    args.read(iprot)
6651 
    iprot.readMessageEnd()
6652 
    result = getOrderListForVendor_result()
6653 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6654 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6655 
    result.write(oprot)
6656 
    oprot.writeMessageEnd()
6657 
    oprot.trans.flush()
6658 
 
1528 ankur.sing 6659 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6660 
    args = getOrderForCustomer_args()
6661 
    args.read(iprot)
6662 
    iprot.readMessageEnd()
6663 
    result = getOrderForCustomer_result()
6664 
    try:
6665 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6666 
    except TransactionServiceException, ex:
6667 
      result.ex = ex
6668 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6669 
    result.write(oprot)
6670 
    oprot.writeMessageEnd()
6671 
    oprot.trans.flush()
6672 
 
3064 chandransh 6673 
  def process_getAlerts(self, seqid, iprot, oprot):
6674 
    args = getAlerts_args()
6675 
    args.read(iprot)
6676 
    iprot.readMessageEnd()
6677 
    result = getAlerts_result()
4444 rajveer 6678 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6679 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6680 
    result.write(oprot)
6681 
    oprot.writeMessageEnd()
6682 
    oprot.trans.flush()
6683 
 
4394 rajveer 6684 
  def process_addAlert(self, seqid, iprot, oprot):
6685 
    args = addAlert_args()
3064 chandransh 6686 
    args.read(iprot)
6687 
    iprot.readMessageEnd()
4394 rajveer 6688 
    result = addAlert_result()
4444 rajveer 6689 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6690 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6691 
    result.write(oprot)
6692 
    oprot.writeMessageEnd()
6693 
    oprot.trans.flush()
6694 
 
4444 rajveer 6695 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6696 
    args = markAlertsAsSeen_args()
6697 
    args.read(iprot)
6698 
    iprot.readMessageEnd()
6699 
    result = markAlertsAsSeen_result()
6700 
    self._handler.markAlertsAsSeen(args.warehouseId)
6701 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6702 
    result.write(oprot)
6703 
    oprot.writeMessageEnd()
6704 
    oprot.trans.flush()
6705 
 
3064 chandransh 6706 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6707 
    args = getValidOrderCount_args()
6708 
    args.read(iprot)
6709 
    iprot.readMessageEnd()
6710 
    result = getValidOrderCount_result()
6711 
    result.success = self._handler.getValidOrderCount()
6712 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6713 
    result.write(oprot)
6714 
    oprot.writeMessageEnd()
6715 
    oprot.trans.flush()
6716 
 
6717 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6718 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6719 
    args.read(iprot)
6720 
    iprot.readMessageEnd()
6721 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6722 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6723 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6724 
    result.write(oprot)
6725 
    oprot.writeMessageEnd()
6726 
    oprot.trans.flush()
6727 
 
6728 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6729 
    args = getValidOrdersAmountRange_args()
6730 
    args.read(iprot)
6731 
    iprot.readMessageEnd()
6732 
    result = getValidOrdersAmountRange_result()
6733 
    result.success = self._handler.getValidOrdersAmountRange()
6734 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6735 
    result.write(oprot)
6736 
    oprot.writeMessageEnd()
6737 
    oprot.trans.flush()
6738 
 
6739 
  def process_getValidOrders(self, seqid, iprot, oprot):
6740 
    args = getValidOrders_args()
6741 
    args.read(iprot)
6742 
    iprot.readMessageEnd()
6743 
    result = getValidOrders_result()
5874 rajveer 6744 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6745 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6746 
    result.write(oprot)
6747 
    oprot.writeMessageEnd()
6748 
    oprot.trans.flush()
6749 
 
1220 chandransh 6750 
  def process_batchOrders(self, seqid, iprot, oprot):
6751 
    args = batchOrders_args()
6752 
    args.read(iprot)
6753 
    iprot.readMessageEnd()
6754 
    result = batchOrders_result()
6755 
    try:
6756 
      result.success = self._handler.batchOrders(args.warehouseId)
6757 
    except TransactionServiceException, ex:
6758 
      result.ex = ex
6759 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6760 
    result.write(oprot)
6761 
    oprot.writeMessageEnd()
6762 
    oprot.trans.flush()
6763 
 
1208 chandransh 6764 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6765 
    args = markOrderAsOutOfStock_args()
6766 
    args.read(iprot)
6767 
    iprot.readMessageEnd()
6768 
    result = markOrderAsOutOfStock_result()
6769 
    try:
6770 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6771 
    except TransactionServiceException, ex:
6772 
      result.ex = ex
6773 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6774 
    result.write(oprot)
6775 
    oprot.writeMessageEnd()
6776 
    oprot.trans.flush()
6777 
 
3064 chandransh 6778 
  def process_verifyOrder(self, seqid, iprot, oprot):
6779 
    args = verifyOrder_args()
759 chandransh 6780 
    args.read(iprot)
6781 
    iprot.readMessageEnd()
3064 chandransh 6782 
    result = verifyOrder_result()
759 chandransh 6783 
    try:
3064 chandransh 6784 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6785 
    except TransactionServiceException, ex:
6786 
      result.ex = ex
3064 chandransh 6787 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6788 
    result.write(oprot)
6789 
    oprot.writeMessageEnd()
6790 
    oprot.trans.flush()
6791 
 
3064 chandransh 6792 
  def process_acceptOrder(self, seqid, iprot, oprot):
6793 
    args = acceptOrder_args()
1113 chandransh 6794 
    args.read(iprot)
6795 
    iprot.readMessageEnd()
3064 chandransh 6796 
    result = acceptOrder_result()
1113 chandransh 6797 
    try:
3064 chandransh 6798 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 6799 
    except TransactionServiceException, ex:
6800 
      result.ex = ex
3064 chandransh 6801 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 6802 
    result.write(oprot)
6803 
    oprot.writeMessageEnd()
6804 
    oprot.trans.flush()
6805 
 
3064 chandransh 6806 
  def process_addBillingDetails(self, seqid, iprot, oprot):
6807 
    args = addBillingDetails_args()
1135 chandransh 6808 
    args.read(iprot)
6809 
    iprot.readMessageEnd()
3064 chandransh 6810 
    result = addBillingDetails_result()
1135 chandransh 6811 
    try:
5110 mandeep.dh 6812 
      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 6813 
    except TransactionServiceException, ex:
6814 
      result.ex = ex
3064 chandransh 6815 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 6816 
    result.write(oprot)
6817 
    oprot.writeMessageEnd()
6818 
    oprot.trans.flush()
6819 
 
4579 rajveer 6820 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
6821 
    args = addInvoiceNumber_args()
6822 
    args.read(iprot)
6823 
    iprot.readMessageEnd()
6824 
    result = addInvoiceNumber_result()
6825 
    try:
4763 rajveer 6826 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 6827 
    except TransactionServiceException, ex:
6828 
      result.ex = ex
6829 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
6830 
    result.write(oprot)
6831 
    oprot.writeMessageEnd()
6832 
    oprot.trans.flush()
6833 
 
4410 rajveer 6834 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
6835 
    args = markOrdersAsShippedFromWarehouse_args()
6836 
    args.read(iprot)
6837 
    iprot.readMessageEnd()
6838 
    result = markOrdersAsShippedFromWarehouse_result()
6839 
    try:
4789 rajveer 6840 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 6841 
    except TransactionServiceException, ex:
6842 
      result.ex = ex
6843 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
6844 
    result.write(oprot)
6845 
    oprot.writeMessageEnd()
6846 
    oprot.trans.flush()
6847 
 
5676 rajveer 6848 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
6849 
    args = markOrdersAsReturnedFromStore_args()
6850 
    args.read(iprot)
6851 
    iprot.readMessageEnd()
6852 
    result = markOrdersAsReturnedFromStore_result()
6853 
    try:
5713 rajveer 6854 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 6855 
    except TransactionServiceException, ex:
6856 
      result.ex = ex
6857 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
6858 
    result.write(oprot)
6859 
    oprot.writeMessageEnd()
6860 
    oprot.trans.flush()
6861 
 
3064 chandransh 6862 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
6863 
    args = markOrdersAsPickedUp_args()
304 ashish 6864 
    args.read(iprot)
6865 
    iprot.readMessageEnd()
3064 chandransh 6866 
    result = markOrdersAsPickedUp_result()
6867 
    try:
4910 phani.kuma 6868 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 6869 
    except TransactionServiceException, ex:
6870 
      result.ex = ex
6871 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 6872 
    result.write(oprot)
6873 
    oprot.writeMessageEnd()
6874 
    oprot.trans.flush()
94 ashish 6875 
 
4910 phani.kuma 6876 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
6877 
    args = getOrdersNotPickedUp_args()
6878 
    args.read(iprot)
6879 
    iprot.readMessageEnd()
6880 
    result = getOrdersNotPickedUp_result()
6881 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
6882 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
6883 
    result.write(oprot)
6884 
    oprot.writeMessageEnd()
6885 
    oprot.trans.flush()
6886 
 
3064 chandransh 6887 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
6888 
    args = markOrdersAsDelivered_args()
304 ashish 6889 
    args.read(iprot)
6890 
    iprot.readMessageEnd()
3064 chandransh 6891 
    result = markOrdersAsDelivered_result()
6892 
    try:
6893 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
6894 
    except TransactionServiceException, ex:
6895 
      result.ex = ex
6896 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 6897 
    result.write(oprot)
6898 
    oprot.writeMessageEnd()
6899 
    oprot.trans.flush()
6900 
 
4910 phani.kuma 6901 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
6902 
    args = markAsRTOrders_args()
1596 ankur.sing 6903 
    args.read(iprot)
6904 
    iprot.readMessageEnd()
4910 phani.kuma 6905 
    result = markAsRTOrders_result()
3064 chandransh 6906 
    try:
4910 phani.kuma 6907 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 6908 
    except TransactionServiceException, ex:
6909 
      result.ex = ex
4910 phani.kuma 6910 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 6911 
    result.write(oprot)
6912 
    oprot.writeMessageEnd()
6913 
    oprot.trans.flush()
304 ashish 6914 
 
4910 phani.kuma 6915 
  def process_getRTOrders(self, seqid, iprot, oprot):
6916 
    args = getRTOrders_args()
6917 
    args.read(iprot)
6918 
    iprot.readMessageEnd()
6919 
    result = getRTOrders_result()
6920 
    result.success = self._handler.getRTOrders(args.providerId)
6921 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
6922 
    result.write(oprot)
6923 
    oprot.writeMessageEnd()
6924 
    oprot.trans.flush()
6925 
 
3064 chandransh 6926 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
6927 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 6928 
    args.read(iprot)
6929 
    iprot.readMessageEnd()
3064 chandransh 6930 
    result = updateNonDeliveryReason_result()
6931 
    try:
4910 phani.kuma 6932 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 6933 
    except TransactionServiceException, ex:
6934 
      result.ex = ex
6935 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 6936 
    result.write(oprot)
6937 
    oprot.writeMessageEnd()
6938 
    oprot.trans.flush()
1596 ankur.sing 6939 
 
4910 phani.kuma 6940 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
6941 
    args = getNonDeliveredOrdersbyCourier_args()
6942 
    args.read(iprot)
6943 
    iprot.readMessageEnd()
6944 
    result = getNonDeliveredOrdersbyCourier_result()
6945 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
6946 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
6947 
    result.write(oprot)
6948 
    oprot.writeMessageEnd()
6949 
    oprot.trans.flush()
6950 
 
6951 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
6952 
    args = markOrdersAsLocalConnected_args()
6953 
    args.read(iprot)
6954 
    iprot.readMessageEnd()
6955 
    result = markOrdersAsLocalConnected_result()
6956 
    try:
6957 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
6958 
    except TransactionServiceException, ex:
6959 
      result.ex = ex
6960 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
6961 
    result.write(oprot)
6962 
    oprot.writeMessageEnd()
6963 
    oprot.trans.flush()
6964 
 
6965 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
6966 
    args = getOrdersNotLocalConnected_args()
6967 
    args.read(iprot)
6968 
    iprot.readMessageEnd()
6969 
    result = getOrdersNotLocalConnected_result()
6970 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
6971 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
6972 
    result.write(oprot)
6973 
    oprot.writeMessageEnd()
6974 
    oprot.trans.flush()
6975 
 
6976 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
6977 
    args = markOrdersAsDestinationCityReached_args()
6978 
    args.read(iprot)
6979 
    iprot.readMessageEnd()
6980 
    result = markOrdersAsDestinationCityReached_result()
6981 
    try:
6982 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
6983 
    except TransactionServiceException, ex:
6984 
      result.ex = ex
6985 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
6986 
    result.write(oprot)
6987 
    oprot.writeMessageEnd()
6988 
    oprot.trans.flush()
6989 
 
6990 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
6991 
    args = markOrdersAsFirstDeliveryAttempted_args()
6992 
    args.read(iprot)
6993 
    iprot.readMessageEnd()
6994 
    result = markOrdersAsFirstDeliveryAttempted_result()
6995 
    try:
6996 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
6997 
    except TransactionServiceException, ex:
6998 
      result.ex = ex
6999 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7000 
    result.write(oprot)
7001 
    oprot.writeMessageEnd()
7002 
    oprot.trans.flush()
7003 
 
3064 chandransh 7004 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7005 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7006 
    args.read(iprot)
7007 
    iprot.readMessageEnd()
3064 chandransh 7008 
    result = getUndeliveredOrders_result()
7009 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7010 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7011 
    result.write(oprot)
7012 
    oprot.writeMessageEnd()
7013 
    oprot.trans.flush()
7014 
 
4783 phani.kuma 7015 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7016 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7017 
    args.read(iprot)
7018 
    iprot.readMessageEnd()
7019 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7020 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7021 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7022 
    result.write(oprot)
7023 
    oprot.writeMessageEnd()
7024 
    oprot.trans.flush()
7025 
 
2536 chandransh 7026 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7027 
    args = toggleDOAFlag_args()
7028 
    args.read(iprot)
7029 
    iprot.readMessageEnd()
7030 
    result = toggleDOAFlag_result()
7031 
    try:
7032 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7033 
    except TransactionServiceException, ex:
7034 
      result.ex = ex
7035 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7036 
    result.write(oprot)
7037 
    oprot.writeMessageEnd()
7038 
    oprot.trans.flush()
1886 ankur.sing 7039 
 
4712 rajveer 7040 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7041 
    args = markOrderAsDelivered_args()
7042 
    args.read(iprot)
7043 
    iprot.readMessageEnd()
7044 
    result = markOrderAsDelivered_result()
7045 
    try:
7046 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7047 
    except TransactionServiceException, ex:
7048 
      result.ex = ex
7049 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7050 
    result.write(oprot)
7051 
    oprot.writeMessageEnd()
7052 
    oprot.trans.flush()
7053 
 
5553 rajveer 7054 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7055 
    args = markOrderAsReceivedAtStore_args()
7056 
    args.read(iprot)
7057 
    iprot.readMessageEnd()
7058 
    result = markOrderAsReceivedAtStore_result()
7059 
    try:
7060 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7061 
    except TransactionServiceException, ex:
7062 
      result.ex = ex
7063 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7064 
    result.write(oprot)
7065 
    oprot.writeMessageEnd()
7066 
    oprot.trans.flush()
7067 
 
4454 rajveer 7068 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7069 
    args = markOrderDoaRequestReceived_args()
7070 
    args.read(iprot)
7071 
    iprot.readMessageEnd()
7072 
    result = markOrderDoaRequestReceived_result()
7073 
    try:
7074 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7075 
    except TransactionServiceException, ex:
7076 
      result.ex = ex
7077 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7078 
    result.write(oprot)
7079 
    oprot.writeMessageEnd()
7080 
    oprot.trans.flush()
7081 
 
7082 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7083 
    args = markOrderDoaRequestAuthorized_args()
7084 
    args.read(iprot)
7085 
    iprot.readMessageEnd()
7086 
    result = markOrderDoaRequestAuthorized_result()
7087 
    try:
7088 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7089 
    except TransactionServiceException, ex:
7090 
      result.ex = ex
7091 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7092 
    result.write(oprot)
7093 
    oprot.writeMessageEnd()
7094 
    oprot.trans.flush()
7095 
 
4488 rajveer 7096 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7097 
    args = markOrderReturnRequestReceived_args()
7098 
    args.read(iprot)
7099 
    iprot.readMessageEnd()
7100 
    result = markOrderReturnRequestReceived_result()
7101 
    try:
7102 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7103 
    except TransactionServiceException, ex:
7104 
      result.ex = ex
7105 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7106 
    result.write(oprot)
7107 
    oprot.writeMessageEnd()
7108 
    oprot.trans.flush()
7109 
 
7110 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7111 
    args = markOrderReturnRequestAuthorized_args()
7112 
    args.read(iprot)
7113 
    iprot.readMessageEnd()
7114 
    result = markOrderReturnRequestAuthorized_result()
7115 
    try:
7116 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7117 
    except TransactionServiceException, ex:
7118 
      result.ex = ex
7119 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7120 
    result.write(oprot)
7121 
    oprot.writeMessageEnd()
7122 
    oprot.trans.flush()
7123 
 
2536 chandransh 7124 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7125 
    args = requestPickupNumber_args()
7126 
    args.read(iprot)
7127 
    iprot.readMessageEnd()
7128 
    result = requestPickupNumber_result()
7129 
    try:
4579 rajveer 7130 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7131 
    except TransactionServiceException, ex:
7132 
      result.ex = ex
7133 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7134 
    result.write(oprot)
7135 
    oprot.writeMessageEnd()
7136 
    oprot.trans.flush()
7137 
 
7138 
  def process_authorizePickup(self, seqid, iprot, oprot):
7139 
    args = authorizePickup_args()
7140 
    args.read(iprot)
7141 
    iprot.readMessageEnd()
7142 
    result = authorizePickup_result()
7143 
    try:
4602 rajveer 7144 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7145 
    except TransactionServiceException, ex:
7146 
      result.ex = ex
7147 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7148 
    result.write(oprot)
7149 
    oprot.writeMessageEnd()
7150 
    oprot.trans.flush()
7151 
 
2764 chandransh 7152 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7153 
    args = markDoasAsPickedUp_args()
7154 
    args.read(iprot)
7155 
    iprot.readMessageEnd()
7156 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7157 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7158 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7159 
    result.write(oprot)
7160 
    oprot.writeMessageEnd()
7161 
    oprot.trans.flush()
7162 
 
4910 phani.kuma 7163 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7164 
    args = getDoasNotPickedUp_args()
7165 
    args.read(iprot)
7166 
    iprot.readMessageEnd()
7167 
    result = getDoasNotPickedUp_result()
7168 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7169 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7170 
    result.write(oprot)
7171 
    oprot.writeMessageEnd()
7172 
    oprot.trans.flush()
7173 
 
4741 phani.kuma 7174 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7175 
    args = markReturnOrdersAsPickedUp_args()
7176 
    args.read(iprot)
7177 
    iprot.readMessageEnd()
7178 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7179 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7180 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7181 
    result.write(oprot)
7182 
    oprot.writeMessageEnd()
7183 
    oprot.trans.flush()
7184 
 
4910 phani.kuma 7185 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7186 
    args = getReturnOrdersNotPickedUp_args()
7187 
    args.read(iprot)
7188 
    iprot.readMessageEnd()
7189 
    result = getReturnOrdersNotPickedUp_result()
7190 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7191 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7192 
    result.write(oprot)
7193 
    oprot.writeMessageEnd()
7194 
    oprot.trans.flush()
7195 
 
2616 chandransh 7196 
  def process_receiveReturn(self, seqid, iprot, oprot):
7197 
    args = receiveReturn_args()
2591 chandransh 7198 
    args.read(iprot)
7199 
    iprot.readMessageEnd()
2616 chandransh 7200 
    result = receiveReturn_result()
2591 chandransh 7201 
    try:
4479 rajveer 7202 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7203 
    except TransactionServiceException, ex:
7204 
      result.ex = ex
2616 chandransh 7205 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7206 
    result.write(oprot)
7207 
    oprot.writeMessageEnd()
7208 
    oprot.trans.flush()
2536 chandransh 7209 
 
2591 chandransh 7210 
  def process_validateDoa(self, seqid, iprot, oprot):
7211 
    args = validateDoa_args()
7212 
    args.read(iprot)
7213 
    iprot.readMessageEnd()
7214 
    result = validateDoa_result()
7215 
    try:
7216 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7217 
    except TransactionServiceException, ex:
7218 
      result.ex = ex
7219 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7220 
    result.write(oprot)
7221 
    oprot.writeMessageEnd()
7222 
    oprot.trans.flush()
7223 
 
4495 rajveer 7224 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7225 
    args = validateReturnProduct_args()
7226 
    args.read(iprot)
7227 
    iprot.readMessageEnd()
7228 
    result = validateReturnProduct_result()
7229 
    try:
7230 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7231 
    except TransactionServiceException, ex:
7232 
      result.ex = ex
7233 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7234 
    result.write(oprot)
7235 
    oprot.writeMessageEnd()
7236 
    oprot.trans.flush()
7237 
 
2616 chandransh 7238 
  def process_reshipOrder(self, seqid, iprot, oprot):
7239 
    args = reshipOrder_args()
7240 
    args.read(iprot)
7241 
    iprot.readMessageEnd()
7242 
    result = reshipOrder_result()
7243 
    try:
7244 
      result.success = self._handler.reshipOrder(args.orderId)
7245 
    except TransactionServiceException, ex:
7246 
      result.ex = ex
7247 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7248 
    result.write(oprot)
7249 
    oprot.writeMessageEnd()
7250 
    oprot.trans.flush()
2591 chandransh 7251 
 
2616 chandransh 7252 
  def process_refundOrder(self, seqid, iprot, oprot):
7253 
    args = refundOrder_args()
7254 
    args.read(iprot)
7255 
    iprot.readMessageEnd()
7256 
    result = refundOrder_result()
7257 
    try:
3226 chandransh 7258 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7259 
    except TransactionServiceException, ex:
7260 
      result.ex = ex
7261 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7262 
    result.write(oprot)
7263 
    oprot.writeMessageEnd()
7264 
    oprot.trans.flush()
7265 
 
2690 chandransh 7266 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7267 
    args = getReturnOrders_args()
7268 
    args.read(iprot)
7269 
    iprot.readMessageEnd()
7270 
    result = getReturnOrders_result()
7271 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7272 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
2616 chandransh 7276 
 
5481 phani.kuma 7277 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7278 
    args = getAllReturnOrders_args()
7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
7281 
    result = getAllReturnOrders_result()
7282 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7283 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7284 
    result.write(oprot)
7285 
    oprot.writeMessageEnd()
7286 
    oprot.trans.flush()
7287 
 
2700 chandransh 7288 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7289 
    args = getReturnOrder_args()
7290 
    args.read(iprot)
7291 
    iprot.readMessageEnd()
7292 
    result = getReturnOrder_result()
7293 
    try:
7294 
      result.success = self._handler.getReturnOrder(args.id)
7295 
    except TransactionServiceException, ex:
7296 
      result.ex = ex
7297 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7298 
    result.write(oprot)
7299 
    oprot.writeMessageEnd()
7300 
    oprot.trans.flush()
7301 
 
2690 chandransh 7302 
  def process_processReturn(self, seqid, iprot, oprot):
7303 
    args = processReturn_args()
7304 
    args.read(iprot)
7305 
    iprot.readMessageEnd()
7306 
    result = processReturn_result()
7307 
    try:
7308 
      self._handler.processReturn(args.returnOrderId)
7309 
    except TransactionServiceException, ex:
7310 
      result.ex = ex
7311 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7312 
    result.write(oprot)
7313 
    oprot.writeMessageEnd()
7314 
    oprot.trans.flush()
7315 
 
3451 chandransh 7316 
  def process_updateWeight(self, seqid, iprot, oprot):
7317 
    args = updateWeight_args()
7318 
    args.read(iprot)
7319 
    iprot.readMessageEnd()
7320 
    result = updateWeight_result()
7321 
    try:
7322 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7323 
    except TransactionServiceException, ex:
7324 
      result.ex = ex
7325 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7326 
    result.write(oprot)
7327 
    oprot.writeMessageEnd()
7328 
    oprot.trans.flush()
2819 chandransh 7329 
 
3469 chandransh 7330 
  def process_changeItem(self, seqid, iprot, oprot):
7331 
    args = changeItem_args()
7332 
    args.read(iprot)
7333 
    iprot.readMessageEnd()
7334 
    result = changeItem_result()
7335 
    try:
7336 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7337 
    except TransactionServiceException, ex:
7338 
      result.ex = ex
7339 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7340 
    result.write(oprot)
7341 
    oprot.writeMessageEnd()
7342 
    oprot.trans.flush()
3451 chandransh 7343 
 
3469 chandransh 7344 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7345 
    args = shiftToWarehouse_args()
7346 
    args.read(iprot)
7347 
    iprot.readMessageEnd()
7348 
    result = shiftToWarehouse_result()
7349 
    try:
7350 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7351 
    except TransactionServiceException, ex:
7352 
      result.ex = ex
7353 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7354 
    result.write(oprot)
7355 
    oprot.writeMessageEnd()
7356 
    oprot.trans.flush()
7357 
 
3553 chandransh 7358 
  def process_addDelayReason(self, seqid, iprot, oprot):
7359 
    args = addDelayReason_args()
7360 
    args.read(iprot)
7361 
    iprot.readMessageEnd()
7362 
    result = addDelayReason_result()
7363 
    try:
4647 rajveer 7364 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7365 
    except TransactionServiceException, ex:
7366 
      result.ex = ex
7367 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7368 
    result.write(oprot)
7369 
    oprot.writeMessageEnd()
7370 
    oprot.trans.flush()
3469 chandransh 7371 
 
3956 chandransh 7372 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7373 
    args = reconcileCodCollection_args()
7374 
    args.read(iprot)
7375 
    iprot.readMessageEnd()
7376 
    result = reconcileCodCollection_result()
7377 
    try:
7378 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7379 
    except TransactionServiceException, ex:
7380 
      result.ex = ex
7381 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7382 
    result.write(oprot)
7383 
    oprot.writeMessageEnd()
7384 
    oprot.trans.flush()
3553 chandransh 7385 
 
4008 mandeep.dh 7386 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7387 
    args = getTransactionsRequiringExtraProcessing_args()
7388 
    args.read(iprot)
7389 
    iprot.readMessageEnd()
7390 
    result = getTransactionsRequiringExtraProcessing_result()
7391 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7392 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7393 
    result.write(oprot)
7394 
    oprot.writeMessageEnd()
7395 
    oprot.trans.flush()
3956 chandransh 7396 
 
4008 mandeep.dh 7397 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7398 
    args = markTransactionAsProcessed_args()
7399 
    args.read(iprot)
7400 
    iprot.readMessageEnd()
7401 
    result = markTransactionAsProcessed_result()
7402 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7403 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7404 
    result.write(oprot)
7405 
    oprot.writeMessageEnd()
7406 
    oprot.trans.flush()
7407 
 
4018 chandransh 7408 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7409 
    args = getItemWiseRiskyOrdersCount_args()
7410 
    args.read(iprot)
7411 
    iprot.readMessageEnd()
7412 
    result = getItemWiseRiskyOrdersCount_result()
7413 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7414 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7415 
    result.write(oprot)
7416 
    oprot.writeMessageEnd()
7417 
    oprot.trans.flush()
4008 mandeep.dh 7418 
 
4295 varun.gupt 7419 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7420 
    args = getOrdersForItemIds_args()
7421 
    args.read(iprot)
7422 
    iprot.readMessageEnd()
7423 
    result = getOrdersForItemIds_result()
7424 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7425 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7426 
    result.write(oprot)
7427 
    oprot.writeMessageEnd()
7428 
    oprot.trans.flush()
7429 
 
4247 rajveer 7430 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7431 
    args = markOrderCancellationRequestReceived_args()
7432 
    args.read(iprot)
7433 
    iprot.readMessageEnd()
7434 
    result = markOrderCancellationRequestReceived_result()
7435 
    try:
7436 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7437 
    except TransactionServiceException, ex:
7438 
      result.ex = ex
7439 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7440 
    result.write(oprot)
7441 
    oprot.writeMessageEnd()
7442 
    oprot.trans.flush()
4018 chandransh 7443 
 
4247 rajveer 7444 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7445 
    args = markOrderCancellationRequestConfirmed_args()
7446 
    args.read(iprot)
7447 
    iprot.readMessageEnd()
7448 
    result = markOrderCancellationRequestConfirmed_result()
7449 
    try:
7450 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7451 
    except TransactionServiceException, ex:
7452 
      result.ex = ex
7453 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7454 
    result.write(oprot)
7455 
    oprot.writeMessageEnd()
7456 
    oprot.trans.flush()
7457 
 
7458 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7459 
    args = markOrderCancellationRequestDenied_args()
7460 
    args.read(iprot)
7461 
    iprot.readMessageEnd()
7462 
    result = markOrderCancellationRequestDenied_result()
7463 
    try:
7464 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7465 
    except TransactionServiceException, ex:
7466 
      result.ex = ex
7467 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7468 
    result.write(oprot)
7469 
    oprot.writeMessageEnd()
7470 
    oprot.trans.flush()
7471 
 
4258 rajveer 7472 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7473 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7474 
    args.read(iprot)
7475 
    iprot.readMessageEnd()
4258 rajveer 7476 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7477 
    try:
4258 rajveer 7478 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7479 
    except TransactionServiceException, ex:
7480 
      result.ex = ex
4258 rajveer 7481 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7482 
    result.write(oprot)
7483 
    oprot.writeMessageEnd()
7484 
    oprot.trans.flush()
7485 
 
4259 anupam.sin 7486 
  def process_refundTransaction(self, seqid, iprot, oprot):
7487 
    args = refundTransaction_args()
7488 
    args.read(iprot)
7489 
    iprot.readMessageEnd()
7490 
    result = refundTransaction_result()
7491 
    try:
7492 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7493 
    except TransactionServiceException, ex:
7494 
      result.ex = ex
7495 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7496 
    result.write(oprot)
7497 
    oprot.writeMessageEnd()
7498 
    oprot.trans.flush()
4247 rajveer 7499 
 
4324 mandeep.dh 7500 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7501 
    args = updateShipmentAddress_args()
7502 
    args.read(iprot)
7503 
    iprot.readMessageEnd()
7504 
    result = updateShipmentAddress_result()
7505 
    try:
7506 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7507 
    except TransactionServiceException, ex:
7508 
      result.ex = ex
7509 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7510 
    result.write(oprot)
7511 
    oprot.writeMessageEnd()
7512 
    oprot.trans.flush()
7513 
 
4285 rajveer 7514 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7515 
    args = acceptOrdersForItemId_args()
7516 
    args.read(iprot)
7517 
    iprot.readMessageEnd()
7518 
    result = acceptOrdersForItemId_result()
7519 
    try:
7520 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7521 
    except TransactionServiceException, ex:
7522 
      result.ex = ex
7523 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7524 
    result.write(oprot)
7525 
    oprot.writeMessageEnd()
7526 
    oprot.trans.flush()
4259 anupam.sin 7527 
 
4303 rajveer 7528 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7529 
    args = markOrdersAsPORaised_args()
7530 
    args.read(iprot)
7531 
    iprot.readMessageEnd()
7532 
    result = markOrdersAsPORaised_result()
7533 
    try:
4369 rajveer 7534 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7535 
    except TransactionServiceException, ex:
7536 
      result.ex = ex
7537 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7538 
    result.write(oprot)
7539 
    oprot.writeMessageEnd()
7540 
    oprot.trans.flush()
4285 rajveer 7541 
 
4303 rajveer 7542 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7543 
    args = markOrdersAsReversalInitiated_args()
7544 
    args.read(iprot)
7545 
    iprot.readMessageEnd()
7546 
    result = markOrdersAsReversalInitiated_result()
7547 
    try:
4369 rajveer 7548 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7549 
    except TransactionServiceException, ex:
7550 
      result.ex = ex
7551 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7552 
    result.write(oprot)
7553 
    oprot.writeMessageEnd()
7554 
    oprot.trans.flush()
7555 
 
7556 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7557 
    args = markOrdersAsNotAvailabke_args()
7558 
    args.read(iprot)
7559 
    iprot.readMessageEnd()
7560 
    result = markOrdersAsNotAvailabke_result()
7561 
    try:
4369 rajveer 7562 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7563 
    except TransactionServiceException, ex:
7564 
      result.ex = ex
7565 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7566 
    result.write(oprot)
7567 
    oprot.writeMessageEnd()
7568 
    oprot.trans.flush()
7569 
 
4369 rajveer 7570 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7571 
    args = markOrdersAsTimeout_args()
7572 
    args.read(iprot)
7573 
    iprot.readMessageEnd()
7574 
    result = markOrdersAsTimeout_result()
7575 
    try:
7576 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7577 
    except TransactionServiceException, ex:
7578 
      result.ex = ex
7579 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7580 
    result.write(oprot)
7581 
    oprot.writeMessageEnd()
7582 
    oprot.trans.flush()
4303 rajveer 7583 
 
4662 rajveer 7584 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7585 
    args = markOrderAsLostInTransit_args()
7586 
    args.read(iprot)
7587 
    iprot.readMessageEnd()
7588 
    result = markOrderAsLostInTransit_result()
7589 
    try:
7590 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7591 
    except TransactionServiceException, ex:
7592 
      result.ex = ex
7593 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7594 
    result.write(oprot)
7595 
    oprot.writeMessageEnd()
7596 
    oprot.trans.flush()
7597 
 
4386 anupam.sin 7598 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7599 
    args = getOrderForAwb_args()
7600 
    args.read(iprot)
7601 
    iprot.readMessageEnd()
7602 
    result = getOrderForAwb_result()
7603 
    try:
7604 
      result.success = self._handler.getOrderForAwb(args.awb)
7605 
    except TransactionServiceException, ex:
7606 
      result.ex = ex
7607 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7608 
    result.write(oprot)
7609 
    oprot.writeMessageEnd()
7610 
    oprot.trans.flush()
4369 rajveer 7611 
 
4506 phani.kuma 7612 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7613 
    args = getOrdersForProviderForStatus_args()
7614 
    args.read(iprot)
7615 
    iprot.readMessageEnd()
7616 
    result = getOrdersForProviderForStatus_result()
7617 
    try:
4910 phani.kuma 7618 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7619 
    except TransactionServiceException, ex:
7620 
      result.ex = ex
7621 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7622 
    result.write(oprot)
7623 
    oprot.writeMessageEnd()
7624 
    oprot.trans.flush()
4386 anupam.sin 7625 
 
4600 varun.gupt 7626 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7627 
    args = getBilledOrdersForVendor_args()
7628 
    args.read(iprot)
7629 
    iprot.readMessageEnd()
7630 
    result = getBilledOrdersForVendor_result()
7631 
    try:
7632 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7633 
    except TransactionServiceException, ex:
7634 
      result.ex = ex
7635 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7636 
    result.write(oprot)
7637 
    oprot.writeMessageEnd()
7638 
    oprot.trans.flush()
4506 phani.kuma 7639 
 
4607 rajveer 7640 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7641 
    args = getSlippedSippingDateOrders_args()
7642 
    args.read(iprot)
7643 
    iprot.readMessageEnd()
7644 
    result = getSlippedSippingDateOrders_result()
7645 
    try:
7646 
      result.success = self._handler.getSlippedSippingDateOrders()
7647 
    except TransactionServiceException, ex:
7648 
      result.ex = ex
7649 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7650 
    result.write(oprot)
7651 
    oprot.writeMessageEnd()
7652 
    oprot.trans.flush()
7653 
 
4709 rajveer 7654 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7655 
    args = getCancelledOrders_args()
7656 
    args.read(iprot)
7657 
    iprot.readMessageEnd()
7658 
    result = getCancelledOrders_result()
7659 
    try:
7660 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7661 
    except TransactionServiceException, ex:
7662 
      result.ex = ex
7663 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7664 
    result.write(oprot)
7665 
    oprot.writeMessageEnd()
7666 
    oprot.trans.flush()
7667 
 
4600 varun.gupt 7668 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7669 
    args = saveBluedartSettlements_args()
7670 
    args.read(iprot)
7671 
    iprot.readMessageEnd()
7672 
    result = saveBluedartSettlements_result()
7673 
    try:
7674 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7675 
    except TransactionServiceException, ex:
7676 
      result.ex = ex
7677 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7678 
    result.write(oprot)
7679 
    oprot.writeMessageEnd()
7680 
    oprot.trans.flush()
7681 
 
7682 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7683 
    args = savePaymentSettlements_args()
7684 
    args.read(iprot)
7685 
    iprot.readMessageEnd()
7686 
    result = savePaymentSettlements_result()
7687 
    try:
4905 varun.gupt 7688 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7689 
    except TransactionServiceException, ex:
7690 
      result.ex = ex
7691 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7692 
    result.write(oprot)
7693 
    oprot.writeMessageEnd()
7694 
    oprot.trans.flush()
7695 
 
7696 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7697 
    args = saveEBSSettlementSummary_args()
7698 
    args.read(iprot)
7699 
    iprot.readMessageEnd()
7700 
    result = saveEBSSettlementSummary_result()
7701 
    try:
7702 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7703 
    except TransactionServiceException, ex:
7704 
      result.ex = ex
7705 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7706 
    result.write(oprot)
7707 
    oprot.writeMessageEnd()
7708 
    oprot.trans.flush()
7709 
 
5386 phani.kuma 7710 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7711 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7712 
    args.read(iprot)
7713 
    iprot.readMessageEnd()
5386 phani.kuma 7714 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7715 
    try:
5386 phani.kuma 7716 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7717 
    except TransactionServiceException, ex:
7718 
      result.ex = ex
5386 phani.kuma 7719 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7720 
    result.write(oprot)
7721 
    oprot.writeMessageEnd()
7722 
    oprot.trans.flush()
7723 
 
5386 phani.kuma 7724 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7725 
    args = getSettlementForCod_args()
7726 
    args.read(iprot)
7727 
    iprot.readMessageEnd()
7728 
    result = getSettlementForCod_result()
7729 
    try:
7730 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7731 
    except TransactionServiceException, ex:
7732 
      result.ex = ex
7733 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7734 
    result.write(oprot)
7735 
    oprot.writeMessageEnd()
7736 
    oprot.trans.flush()
7737 
 
4600 varun.gupt 7738 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7739 
    args = getEBSSettlementSummaries_args()
7740 
    args.read(iprot)
7741 
    iprot.readMessageEnd()
7742 
    result = getEBSSettlementSummaries_result()
7743 
    try:
7744 
      result.success = self._handler.getEBSSettlementSummaries()
7745 
    except TransactionServiceException, ex:
7746 
      result.ex = ex
7747 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7748 
    result.write(oprot)
7749 
    oprot.writeMessageEnd()
7750 
    oprot.trans.flush()
7751 
 
7752 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7753 
    args = markEBSSettlementUploaded_args()
7754 
    args.read(iprot)
7755 
    iprot.readMessageEnd()
7756 
    result = markEBSSettlementUploaded_result()
7757 
    try:
7758 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7759 
    except TransactionServiceException, ex:
7760 
      result.ex = ex
7761 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7762 
    result.write(oprot)
7763 
    oprot.writeMessageEnd()
7764 
    oprot.trans.flush()
7765 
 
7766 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7767 
    args = getEBSSettlementDate_args()
7768 
    args.read(iprot)
7769 
    iprot.readMessageEnd()
7770 
    result = getEBSSettlementDate_result()
7771 
    try:
7772 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7773 
    except TransactionServiceException, ex:
7774 
      result.ex = ex
7775 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7776 
    result.write(oprot)
7777 
    oprot.writeMessageEnd()
7778 
    oprot.trans.flush()
7779 
 
4715 varun.gupt 7780 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7781 
    args = getSettlementsByDate_args()
7782 
    args.read(iprot)
7783 
    iprot.readMessageEnd()
7784 
    result = getSettlementsByDate_result()
7785 
    try:
7786 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7787 
    except TransactionServiceException, ex:
7788 
      result.ex = ex
7789 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7790 
    result.write(oprot)
7791 
    oprot.writeMessageEnd()
7792 
    oprot.trans.flush()
4600 varun.gupt 7793 
 
4715 varun.gupt 7794 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7795 
    args = getReshippedOrderIds_args()
7796 
    args.read(iprot)
7797 
    iprot.readMessageEnd()
7798 
    result = getReshippedOrderIds_result()
7799 
    try:
7800 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
7801 
    except TransactionServiceException, ex:
7802 
      result.ex = ex
7803 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
7804 
    result.write(oprot)
7805 
    oprot.writeMessageEnd()
7806 
    oprot.trans.flush()
7807 
 
5481 phani.kuma 7808 
  def process_getBilledOrders(self, seqid, iprot, oprot):
7809 
    args = getBilledOrders_args()
4875 varun.gupt 7810 
    args.read(iprot)
7811 
    iprot.readMessageEnd()
5481 phani.kuma 7812 
    result = getBilledOrders_result()
4875 varun.gupt 7813 
    try:
5481 phani.kuma 7814 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 7815 
    except TransactionServiceException, ex:
7816 
      result.ex = ex
5481 phani.kuma 7817 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 7818 
    result.write(oprot)
7819 
    oprot.writeMessageEnd()
7820 
    oprot.trans.flush()
4757 mandeep.dh 7821 
 
5031 varun.gupt 7822 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
7823 
    args = getStatusDistributionOfOrders_args()
7824 
    args.read(iprot)
7825 
    iprot.readMessageEnd()
7826 
    result = getStatusDistributionOfOrders_result()
7827 
    try:
7828 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
7829 
    except TransactionServiceException, ex:
7830 
      result.ex = ex
7831 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
7832 
    result.write(oprot)
7833 
    oprot.writeMessageEnd()
7834 
    oprot.trans.flush()
4875 varun.gupt 7835 
 
5067 varun.gupt 7836 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
7837 
    args = getOrderIdsForStatus_args()
7838 
    args.read(iprot)
7839 
    iprot.readMessageEnd()
7840 
    result = getOrderIdsForStatus_result()
7841 
    try:
7842 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
7843 
    except TransactionServiceException, ex:
7844 
      result.ex = ex
7845 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
7846 
    result.write(oprot)
7847 
    oprot.writeMessageEnd()
7848 
    oprot.trans.flush()
5031 varun.gupt 7849 
 
5348 anupam.sin 7850 
  def process_updateCODAgent(self, seqid, iprot, oprot):
7851 
    args = updateCODAgent_args()
7852 
    args.read(iprot)
7853 
    iprot.readMessageEnd()
7854 
    result = updateCODAgent_result()
7855 
    try:
7856 
      self._handler.updateCODAgent(args.agent, args.orderId)
7857 
    except TransactionServiceException, ex:
7858 
      result.ex = ex
7859 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
7860 
    result.write(oprot)
7861 
    oprot.writeMessageEnd()
7862 
    oprot.trans.flush()
7863 
 
5099 varun.gupt 7864 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
7865 
    args = updateOrderAsPaidToVendor_args()
7866 
    args.read(iprot)
7867 
    iprot.readMessageEnd()
7868 
    result = updateOrderAsPaidToVendor_result()
7869 
    try:
7870 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
7871 
    except TransactionServiceException, ex:
7872 
      result.ex = ex
7873 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
7874 
    result.write(oprot)
7875 
    oprot.writeMessageEnd()
7876 
    oprot.trans.flush()
5067 varun.gupt 7877 
 
5386 phani.kuma 7878 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
7879 
    args = updateOrderOnlyAsPaidToVendor_args()
7880 
    args.read(iprot)
7881 
    iprot.readMessageEnd()
7882 
    result = updateOrderOnlyAsPaidToVendor_result()
7883 
    try:
7884 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
7885 
    except TransactionServiceException, ex:
7886 
      result.ex = ex
7887 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
7888 
    result.write(oprot)
7889 
    oprot.writeMessageEnd()
7890 
    oprot.trans.flush()
7891 
 
5208 varun.gupt 7892 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
7893 
    args = getRefundedOrdersMarkedPaid_args()
7894 
    args.read(iprot)
7895 
    iprot.readMessageEnd()
7896 
    result = getRefundedOrdersMarkedPaid_result()
7897 
    try:
7898 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
7899 
    except TransactionServiceException, ex:
7900 
      result.ex = ex
7901 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
7902 
    result.write(oprot)
7903 
    oprot.writeMessageEnd()
7904 
    oprot.trans.flush()
5099 varun.gupt 7905 
 
5447 anupam.sin 7906 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
7907 
    args = getAllVerificationAgents_args()
7908 
    args.read(iprot)
7909 
    iprot.readMessageEnd()
7910 
    result = getAllVerificationAgents_result()
7911 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
7912 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
7913 
    result.write(oprot)
7914 
    oprot.writeMessageEnd()
7915 
    oprot.trans.flush()
5208 varun.gupt 7916 
 
5527 anupam.sin 7917 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
7918 
    args = getAllAttributesForOrderId_args()
7919 
    args.read(iprot)
7920 
    iprot.readMessageEnd()
7921 
    result = getAllAttributesForOrderId_result()
7922 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
7923 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
7924 
    result.write(oprot)
7925 
    oprot.writeMessageEnd()
7926 
    oprot.trans.flush()
5447 anupam.sin 7927 
 
5676 rajveer 7928 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
7929 
    args = setOrderAttributes_args()
7930 
    args.read(iprot)
7931 
    iprot.readMessageEnd()
7932 
    result = setOrderAttributes_result()
7933 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
7934 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
7938 
 
5527 anupam.sin 7939 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
7940 
    args = setOrderAttributeForTransaction_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = setOrderAttributeForTransaction_result()
7944 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
7945 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
7946 
    result.write(oprot)
7947 
    oprot.writeMessageEnd()
7948 
    oprot.trans.flush()
7949 
 
5553 rajveer 7950 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
7951 
    args = getReceivePendingOrders_args()
7952 
    args.read(iprot)
7953 
    iprot.readMessageEnd()
7954 
    result = getReceivePendingOrders_result()
7955 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
7956 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
7957 
    result.write(oprot)
7958 
    oprot.writeMessageEnd()
7959 
    oprot.trans.flush()
5527 anupam.sin 7960 
 
5553 rajveer 7961 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
7962 
    args = getReceivedAtStoreOrders_args()
7963 
    args.read(iprot)
7964 
    iprot.readMessageEnd()
7965 
    result = getReceivedAtStoreOrders_result()
7966 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
7967 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
7968 
    result.write(oprot)
7969 
    oprot.writeMessageEnd()
7970 
    oprot.trans.flush()
7971 
 
5713 rajveer 7972 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
7973 
    args = getOrdersCollectionAtStore_args()
7974 
    args.read(iprot)
7975 
    iprot.readMessageEnd()
7976 
    result = getOrdersCollectionAtStore_result()
7977 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
7978 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
7979 
    result.write(oprot)
7980 
    oprot.writeMessageEnd()
7981 
    oprot.trans.flush()
7982 
 
5833 rajveer 7983 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
7984 
    args = getOrderAttributeValue_args()
7985 
    args.read(iprot)
7986 
    iprot.readMessageEnd()
7987 
    result = getOrderAttributeValue_result()
7988 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
7989 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
7990 
    result.write(oprot)
7991 
    oprot.writeMessageEnd()
7992 
    oprot.trans.flush()
7993 
 
6019 rajveer 7994 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
7995 
    args = changeJacketNumber_args()
7996 
    args.read(iprot)
7997 
    iprot.readMessageEnd()
7998 
    result = changeJacketNumber_result()
7999 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8000 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8001 
    result.write(oprot)
8002 
    oprot.writeMessageEnd()
8003 
    oprot.trans.flush()
8004 
 
8005 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8006 
    args = markOrderAsRtoInTransit_args()
8007 
    args.read(iprot)
8008 
    iprot.readMessageEnd()
8009 
    result = markOrderAsRtoInTransit_result()
8010 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8011 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8012 
    result.write(oprot)
8013 
    oprot.writeMessageEnd()
8014 
    oprot.trans.flush()
8015 
 
5593 mandeep.dh 8016 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8017 
    args = acceptOrderForItem_args()
8018 
    args.read(iprot)
8019 
    iprot.readMessageEnd()
8020 
    result = acceptOrderForItem_result()
8021 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8022 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8023 
    result.write(oprot)
8024 
    oprot.writeMessageEnd()
8025 
    oprot.trans.flush()
5553 rajveer 8026 
 
6000 mandeep.dh 8027 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8028 
    args = createRechargeOrder_args()
8029 
    args.read(iprot)
8030 
    iprot.readMessageEnd()
8031 
    result = createRechargeOrder_result()
8032 
    try:
8033 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8034 
    except TransactionServiceException, ex:
8035 
      result.ex = ex
8036 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8037 
    result.write(oprot)
8038 
    oprot.writeMessageEnd()
8039 
    oprot.trans.flush()
5593 mandeep.dh 8040 
 
6031 rajveer 8041 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8042 
    args = getRechargeOrder_args()
8043 
    args.read(iprot)
8044 
    iprot.readMessageEnd()
8045 
    result = getRechargeOrder_result()
8046 
    try:
8047 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8048 
    except TransactionServiceException, ex:
8049 
      result.ex = ex
8050 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8051 
    result.write(oprot)
8052 
    oprot.writeMessageEnd()
8053 
    oprot.trans.flush()
8054 
 
8055 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8056 
    args = getRechargeOrders_args()
8057 
    args.read(iprot)
8058 
    iprot.readMessageEnd()
8059 
    result = getRechargeOrders_result()
8060 
    result.success = self._handler.getRechargeOrders(args.userId)
8061 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8062 
    result.write(oprot)
8063 
    oprot.writeMessageEnd()
8064 
    oprot.trans.flush()
8065 
 
6000 mandeep.dh 8066 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8067 
    args = updateRechargeOrderStatus_args()
8068 
    args.read(iprot)
8069 
    iprot.readMessageEnd()
8070 
    result = updateRechargeOrderStatus_result()
8071 
    try:
6031 rajveer 8072 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8073 
    except TransactionServiceException, ex:
8074 
      result.ex = ex
8075 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8076 
    result.write(oprot)
8077 
    oprot.writeMessageEnd()
8078 
    oprot.trans.flush()
8079 
 
8080 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8081 
    args = activateRechargeTxn_args()
8082 
    args.read(iprot)
8083 
    iprot.readMessageEnd()
8084 
    result = activateRechargeTxn_result()
8085 
    try:
6031 rajveer 8086 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8087 
    except TransactionServiceException, ex:
8088 
      result.ex = ex
8089 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8090 
    result.write(oprot)
8091 
    oprot.writeMessageEnd()
8092 
    oprot.trans.flush()
8093 
 
6031 rajveer 8094 
  def process_getUserWallet(self, seqid, iprot, oprot):
8095 
    args = getUserWallet_args()
6000 mandeep.dh 8096 
    args.read(iprot)
8097 
    iprot.readMessageEnd()
6031 rajveer 8098 
    result = getUserWallet_result()
8099 
    result.success = self._handler.getUserWallet(args.userId)
8100 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8101 
    result.write(oprot)
8102 
    oprot.writeMessageEnd()
8103 
    oprot.trans.flush()
8104 
 
6031 rajveer 8105 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8106 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8107 
    args.read(iprot)
8108 
    iprot.readMessageEnd()
6031 rajveer 8109 
    result = getUserWalletHistory_result()
8110 
    result.success = self._handler.getUserWalletHistory(args.userId)
8111 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8112 
    result.write(oprot)
8113 
    oprot.writeMessageEnd()
8114 
    oprot.trans.flush()
8115 
 
6050 anupam.sin 8116 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8117 
    args = getRechargeOrdersForTransaction_args()
8118 
    args.read(iprot)
8119 
    iprot.readMessageEnd()
8120 
    result = getRechargeOrdersForTransaction_result()
8121 
    try:
8122 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8123 
    except TransactionServiceException, ex:
8124 
      result.ex = ex
8125 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8126 
    result.write(oprot)
8127 
    oprot.writeMessageEnd()
8128 
    oprot.trans.flush()
8129 
 
6048 rajveer 8130 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8131 
    args = getServiceProviders_args()
8132 
    args.read(iprot)
8133 
    iprot.readMessageEnd()
8134 
    result = getServiceProviders_result()
8135 
    result.success = self._handler.getServiceProviders(args.rechargeType)
8136 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8137 
    result.write(oprot)
8138 
    oprot.writeMessageEnd()
8139 
    oprot.trans.flush()
6000 mandeep.dh 8140 
 
6048 rajveer 8141 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8142 
    args = getServiceProviderForDevice_args()
8143 
    args.read(iprot)
8144 
    iprot.readMessageEnd()
8145 
    result = getServiceProviderForDevice_result()
6049 rajveer 8146 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8147 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8148 
    result.write(oprot)
8149 
    oprot.writeMessageEnd()
8150 
    oprot.trans.flush()
8151 
 
6094 rajveer 8152 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8153 
    args = getRechargeOrdersForDevice_args()
8154 
    args.read(iprot)
8155 
    iprot.readMessageEnd()
8156 
    result = getRechargeOrdersForDevice_result()
8157 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8158 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
6048 rajveer 8162 
 
6094 rajveer 8163 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8164 
    args = addAmountToWallet_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = addAmountToWallet_result()
8168 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8169 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8170 
    result.write(oprot)
8171 
    oprot.writeMessageEnd()
8172 
    oprot.trans.flush()
8173 
 
8174 
 
94 ashish 8175 
# HELPER FUNCTIONS AND STRUCTURES
8176 
 
8177 
class createTransaction_args:
8178 
  """
8179 
  Attributes:
8180 
   - transaction
8181 
  """
8182 
 
8183 
  thrift_spec = (
8184 
    None, # 0
8185 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8186 
  )
8187 
 
8188 
  def __init__(self, transaction=None,):
8189 
    self.transaction = transaction
8190 
 
8191 
  def read(self, iprot):
8192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8194 
      return
8195 
    iprot.readStructBegin()
8196 
    while True:
8197 
      (fname, ftype, fid) = iprot.readFieldBegin()
8198 
      if ftype == TType.STOP:
8199 
        break
8200 
      if fid == 1:
8201 
        if ftype == TType.STRUCT:
8202 
          self.transaction = Transaction()
8203 
          self.transaction.read(iprot)
8204 
        else:
8205 
          iprot.skip(ftype)
8206 
      else:
8207 
        iprot.skip(ftype)
8208 
      iprot.readFieldEnd()
8209 
    iprot.readStructEnd()
8210 
 
8211 
  def write(self, oprot):
8212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8214 
      return
8215 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8216 
    if self.transaction is not None:
94 ashish 8217 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8218 
      self.transaction.write(oprot)
8219 
      oprot.writeFieldEnd()
8220 
    oprot.writeFieldStop()
8221 
    oprot.writeStructEnd()
8222 
 
3431 rajveer 8223 
  def validate(self):
8224 
    return
8225 
 
8226 
 
94 ashish 8227 
  def __repr__(self):
8228 
    L = ['%s=%r' % (key, value)
8229 
      for key, value in self.__dict__.iteritems()]
8230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8231 
 
8232 
  def __eq__(self, other):
8233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8234 
 
8235 
  def __ne__(self, other):
8236 
    return not (self == other)
8237 
 
8238 
class createTransaction_result:
8239 
  """
8240 
  Attributes:
132 ashish 8241 
   - success
94 ashish 8242 
   - ex
8243 
  """
8244 
 
8245 
  thrift_spec = (
132 ashish 8246 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8248 
  )
8249 
 
132 ashish 8250 
  def __init__(self, success=None, ex=None,):
8251 
    self.success = success
94 ashish 8252 
    self.ex = ex
8253 
 
8254 
  def read(self, iprot):
8255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8257 
      return
8258 
    iprot.readStructBegin()
8259 
    while True:
8260 
      (fname, ftype, fid) = iprot.readFieldBegin()
8261 
      if ftype == TType.STOP:
8262 
        break
132 ashish 8263 
      if fid == 0:
8264 
        if ftype == TType.I64:
8265 
          self.success = iprot.readI64();
8266 
        else:
8267 
          iprot.skip(ftype)
8268 
      elif fid == 1:
94 ashish 8269 
        if ftype == TType.STRUCT:
8270 
          self.ex = TransactionServiceException()
8271 
          self.ex.read(iprot)
8272 
        else:
8273 
          iprot.skip(ftype)
8274 
      else:
8275 
        iprot.skip(ftype)
8276 
      iprot.readFieldEnd()
8277 
    iprot.readStructEnd()
8278 
 
8279 
  def write(self, oprot):
8280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8282 
      return
8283 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8284 
    if self.success is not None:
132 ashish 8285 
      oprot.writeFieldBegin('success', TType.I64, 0)
8286 
      oprot.writeI64(self.success)
8287 
      oprot.writeFieldEnd()
3431 rajveer 8288 
    if self.ex is not None:
94 ashish 8289 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8290 
      self.ex.write(oprot)
8291 
      oprot.writeFieldEnd()
8292 
    oprot.writeFieldStop()
8293 
    oprot.writeStructEnd()
8294 
 
3431 rajveer 8295 
  def validate(self):
8296 
    return
8297 
 
8298 
 
94 ashish 8299 
  def __repr__(self):
8300 
    L = ['%s=%r' % (key, value)
8301 
      for key, value in self.__dict__.iteritems()]
8302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8303 
 
8304 
  def __eq__(self, other):
8305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8306 
 
8307 
  def __ne__(self, other):
8308 
    return not (self == other)
8309 
 
8310 
class getTransaction_args:
8311 
  """
8312 
  Attributes:
8313 
   - id
8314 
  """
8315 
 
8316 
  thrift_spec = (
8317 
    None, # 0
8318 
    (1, TType.I64, 'id', None, None, ), # 1
8319 
  )
8320 
 
8321 
  def __init__(self, id=None,):
8322 
    self.id = id
8323 
 
8324 
  def read(self, iprot):
8325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8327 
      return
8328 
    iprot.readStructBegin()
8329 
    while True:
8330 
      (fname, ftype, fid) = iprot.readFieldBegin()
8331 
      if ftype == TType.STOP:
8332 
        break
8333 
      if fid == 1:
8334 
        if ftype == TType.I64:
8335 
          self.id = iprot.readI64();
8336 
        else:
8337 
          iprot.skip(ftype)
8338 
      else:
8339 
        iprot.skip(ftype)
8340 
      iprot.readFieldEnd()
8341 
    iprot.readStructEnd()
8342 
 
8343 
  def write(self, oprot):
8344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8346 
      return
8347 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8348 
    if self.id is not None:
94 ashish 8349 
      oprot.writeFieldBegin('id', TType.I64, 1)
8350 
      oprot.writeI64(self.id)
8351 
      oprot.writeFieldEnd()
8352 
    oprot.writeFieldStop()
8353 
    oprot.writeStructEnd()
8354 
 
3431 rajveer 8355 
  def validate(self):
8356 
    return
8357 
 
8358 
 
94 ashish 8359 
  def __repr__(self):
8360 
    L = ['%s=%r' % (key, value)
8361 
      for key, value in self.__dict__.iteritems()]
8362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8363 
 
8364 
  def __eq__(self, other):
8365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8366 
 
8367 
  def __ne__(self, other):
8368 
    return not (self == other)
8369 
 
8370 
class getTransaction_result:
8371 
  """
8372 
  Attributes:
8373 
   - success
8374 
   - ex
8375 
  """
8376 
 
8377 
  thrift_spec = (
8378 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8380 
  )
8381 
 
8382 
  def __init__(self, success=None, ex=None,):
8383 
    self.success = success
8384 
    self.ex = ex
8385 
 
8386 
  def read(self, iprot):
8387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8389 
      return
8390 
    iprot.readStructBegin()
8391 
    while True:
8392 
      (fname, ftype, fid) = iprot.readFieldBegin()
8393 
      if ftype == TType.STOP:
8394 
        break
8395 
      if fid == 0:
8396 
        if ftype == TType.STRUCT:
8397 
          self.success = Transaction()
8398 
          self.success.read(iprot)
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      elif fid == 1:
8402 
        if ftype == TType.STRUCT:
8403 
          self.ex = TransactionServiceException()
8404 
          self.ex.read(iprot)
8405 
        else:
8406 
          iprot.skip(ftype)
8407 
      else:
8408 
        iprot.skip(ftype)
8409 
      iprot.readFieldEnd()
8410 
    iprot.readStructEnd()
8411 
 
8412 
  def write(self, oprot):
8413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8415 
      return
8416 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8417 
    if self.success is not None:
94 ashish 8418 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8419 
      self.success.write(oprot)
8420 
      oprot.writeFieldEnd()
3431 rajveer 8421 
    if self.ex is not None:
94 ashish 8422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8423 
      self.ex.write(oprot)
8424 
      oprot.writeFieldEnd()
8425 
    oprot.writeFieldStop()
8426 
    oprot.writeStructEnd()
8427 
 
3431 rajveer 8428 
  def validate(self):
8429 
    return
8430 
 
8431 
 
94 ashish 8432 
  def __repr__(self):
8433 
    L = ['%s=%r' % (key, value)
8434 
      for key, value in self.__dict__.iteritems()]
8435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8436 
 
8437 
  def __eq__(self, other):
8438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8439 
 
8440 
  def __ne__(self, other):
8441 
    return not (self == other)
8442 
 
8443 
class getTransactionsForCustomer_args:
8444 
  """
8445 
  Attributes:
8446 
   - customerId
8447 
   - from_date
8448 
   - to_date
8449 
   - status
8450 
  """
8451 
 
8452 
  thrift_spec = (
8453 
    None, # 0
8454 
    (1, TType.I64, 'customerId', None, None, ), # 1
8455 
    (2, TType.I64, 'from_date', None, None, ), # 2
8456 
    (3, TType.I64, 'to_date', None, None, ), # 3
8457 
    (4, TType.I32, 'status', None, None, ), # 4
8458 
  )
8459 
 
8460 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8461 
    self.customerId = customerId
8462 
    self.from_date = from_date
8463 
    self.to_date = to_date
8464 
    self.status = status
8465 
 
8466 
  def read(self, iprot):
8467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8469 
      return
8470 
    iprot.readStructBegin()
8471 
    while True:
8472 
      (fname, ftype, fid) = iprot.readFieldBegin()
8473 
      if ftype == TType.STOP:
8474 
        break
8475 
      if fid == 1:
8476 
        if ftype == TType.I64:
8477 
          self.customerId = iprot.readI64();
8478 
        else:
8479 
          iprot.skip(ftype)
8480 
      elif fid == 2:
8481 
        if ftype == TType.I64:
8482 
          self.from_date = iprot.readI64();
8483 
        else:
8484 
          iprot.skip(ftype)
8485 
      elif fid == 3:
8486 
        if ftype == TType.I64:
8487 
          self.to_date = iprot.readI64();
8488 
        else:
8489 
          iprot.skip(ftype)
8490 
      elif fid == 4:
8491 
        if ftype == TType.I32:
8492 
          self.status = iprot.readI32();
8493 
        else:
8494 
          iprot.skip(ftype)
8495 
      else:
8496 
        iprot.skip(ftype)
8497 
      iprot.readFieldEnd()
8498 
    iprot.readStructEnd()
8499 
 
8500 
  def write(self, oprot):
8501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8503 
      return
8504 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8505 
    if self.customerId is not None:
94 ashish 8506 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8507 
      oprot.writeI64(self.customerId)
8508 
      oprot.writeFieldEnd()
3431 rajveer 8509 
    if self.from_date is not None:
94 ashish 8510 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8511 
      oprot.writeI64(self.from_date)
8512 
      oprot.writeFieldEnd()
3431 rajveer 8513 
    if self.to_date is not None:
94 ashish 8514 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8515 
      oprot.writeI64(self.to_date)
8516 
      oprot.writeFieldEnd()
3431 rajveer 8517 
    if self.status is not None:
94 ashish 8518 
      oprot.writeFieldBegin('status', TType.I32, 4)
8519 
      oprot.writeI32(self.status)
8520 
      oprot.writeFieldEnd()
8521 
    oprot.writeFieldStop()
8522 
    oprot.writeStructEnd()
8523 
 
3431 rajveer 8524 
  def validate(self):
8525 
    return
8526 
 
8527 
 
94 ashish 8528 
  def __repr__(self):
8529 
    L = ['%s=%r' % (key, value)
8530 
      for key, value in self.__dict__.iteritems()]
8531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8532 
 
8533 
  def __eq__(self, other):
8534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8535 
 
8536 
  def __ne__(self, other):
8537 
    return not (self == other)
8538 
 
8539 
class getTransactionsForCustomer_result:
8540 
  """
8541 
  Attributes:
8542 
   - success
8543 
   - ex
8544 
  """
8545 
 
8546 
  thrift_spec = (
8547 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8549 
  )
8550 
 
8551 
  def __init__(self, success=None, ex=None,):
8552 
    self.success = success
8553 
    self.ex = ex
8554 
 
8555 
  def read(self, iprot):
8556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8558 
      return
8559 
    iprot.readStructBegin()
8560 
    while True:
8561 
      (fname, ftype, fid) = iprot.readFieldBegin()
8562 
      if ftype == TType.STOP:
8563 
        break
8564 
      if fid == 0:
8565 
        if ftype == TType.LIST:
8566 
          self.success = []
6031 rajveer 8567 
          (_etype66, _size63) = iprot.readListBegin()
8568 
          for _i67 in xrange(_size63):
8569 
            _elem68 = Transaction()
8570 
            _elem68.read(iprot)
8571 
            self.success.append(_elem68)
94 ashish 8572 
          iprot.readListEnd()
8573 
        else:
8574 
          iprot.skip(ftype)
8575 
      elif fid == 1:
8576 
        if ftype == TType.STRUCT:
8577 
          self.ex = TransactionServiceException()
8578 
          self.ex.read(iprot)
8579 
        else:
8580 
          iprot.skip(ftype)
8581 
      else:
8582 
        iprot.skip(ftype)
8583 
      iprot.readFieldEnd()
8584 
    iprot.readStructEnd()
8585 
 
8586 
  def write(self, oprot):
8587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8589 
      return
8590 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8591 
    if self.success is not None:
94 ashish 8592 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8593 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8594 
      for iter69 in self.success:
8595 
        iter69.write(oprot)
94 ashish 8596 
      oprot.writeListEnd()
8597 
      oprot.writeFieldEnd()
3431 rajveer 8598 
    if self.ex is not None:
94 ashish 8599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8600 
      self.ex.write(oprot)
8601 
      oprot.writeFieldEnd()
8602 
    oprot.writeFieldStop()
8603 
    oprot.writeStructEnd()
8604 
 
3431 rajveer 8605 
  def validate(self):
8606 
    return
8607 
 
8608 
 
94 ashish 8609 
  def __repr__(self):
8610 
    L = ['%s=%r' % (key, value)
8611 
      for key, value in self.__dict__.iteritems()]
8612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8613 
 
8614 
  def __eq__(self, other):
8615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8616 
 
8617 
  def __ne__(self, other):
8618 
    return not (self == other)
8619 
 
132 ashish 8620 
class getTransactionsForShoppingCartId_args:
8621 
  """
8622 
  Attributes:
8623 
   - shoppingCartId
8624 
  """
8625 
 
8626 
  thrift_spec = (
8627 
    None, # 0
8628 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8629 
  )
8630 
 
8631 
  def __init__(self, shoppingCartId=None,):
8632 
    self.shoppingCartId = shoppingCartId
8633 
 
8634 
  def read(self, iprot):
8635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8637 
      return
8638 
    iprot.readStructBegin()
8639 
    while True:
8640 
      (fname, ftype, fid) = iprot.readFieldBegin()
8641 
      if ftype == TType.STOP:
8642 
        break
8643 
      if fid == 1:
8644 
        if ftype == TType.I64:
8645 
          self.shoppingCartId = iprot.readI64();
8646 
        else:
8647 
          iprot.skip(ftype)
8648 
      else:
8649 
        iprot.skip(ftype)
8650 
      iprot.readFieldEnd()
8651 
    iprot.readStructEnd()
8652 
 
8653 
  def write(self, oprot):
8654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8656 
      return
8657 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8658 
    if self.shoppingCartId is not None:
132 ashish 8659 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8660 
      oprot.writeI64(self.shoppingCartId)
8661 
      oprot.writeFieldEnd()
8662 
    oprot.writeFieldStop()
8663 
    oprot.writeStructEnd()
8664 
 
3431 rajveer 8665 
  def validate(self):
8666 
    return
8667 
 
8668 
 
132 ashish 8669 
  def __repr__(self):
8670 
    L = ['%s=%r' % (key, value)
8671 
      for key, value in self.__dict__.iteritems()]
8672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8673 
 
8674 
  def __eq__(self, other):
8675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8676 
 
8677 
  def __ne__(self, other):
8678 
    return not (self == other)
8679 
 
8680 
class getTransactionsForShoppingCartId_result:
8681 
  """
8682 
  Attributes:
8683 
   - success
8684 
   - ex
8685 
  """
8686 
 
8687 
  thrift_spec = (
8688 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8690 
  )
8691 
 
8692 
  def __init__(self, success=None, ex=None,):
8693 
    self.success = success
8694 
    self.ex = ex
8695 
 
8696 
  def read(self, iprot):
8697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8699 
      return
8700 
    iprot.readStructBegin()
8701 
    while True:
8702 
      (fname, ftype, fid) = iprot.readFieldBegin()
8703 
      if ftype == TType.STOP:
8704 
        break
8705 
      if fid == 0:
8706 
        if ftype == TType.LIST:
8707 
          self.success = []
6031 rajveer 8708 
          (_etype73, _size70) = iprot.readListBegin()
8709 
          for _i74 in xrange(_size70):
8710 
            _elem75 = Transaction()
8711 
            _elem75.read(iprot)
8712 
            self.success.append(_elem75)
132 ashish 8713 
          iprot.readListEnd()
8714 
        else:
8715 
          iprot.skip(ftype)
8716 
      elif fid == 1:
8717 
        if ftype == TType.STRUCT:
8718 
          self.ex = TransactionServiceException()
8719 
          self.ex.read(iprot)
8720 
        else:
8721 
          iprot.skip(ftype)
8722 
      else:
8723 
        iprot.skip(ftype)
8724 
      iprot.readFieldEnd()
8725 
    iprot.readStructEnd()
8726 
 
8727 
  def write(self, oprot):
8728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8730 
      return
8731 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8732 
    if self.success is not None:
132 ashish 8733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 8735 
      for iter76 in self.success:
8736 
        iter76.write(oprot)
132 ashish 8737 
      oprot.writeListEnd()
8738 
      oprot.writeFieldEnd()
3431 rajveer 8739 
    if self.ex is not None:
132 ashish 8740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8741 
      self.ex.write(oprot)
8742 
      oprot.writeFieldEnd()
8743 
    oprot.writeFieldStop()
8744 
    oprot.writeStructEnd()
8745 
 
3431 rajveer 8746 
  def validate(self):
8747 
    return
8748 
 
8749 
 
132 ashish 8750 
  def __repr__(self):
8751 
    L = ['%s=%r' % (key, value)
8752 
      for key, value in self.__dict__.iteritems()]
8753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8754 
 
8755 
  def __eq__(self, other):
8756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8757 
 
8758 
  def __ne__(self, other):
8759 
    return not (self == other)
8760 
 
94 ashish 8761 
class getTransactionStatus_args:
8762 
  """
8763 
  Attributes:
8764 
   - transactionId
8765 
  """
8766 
 
8767 
  thrift_spec = (
8768 
    None, # 0
8769 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8770 
  )
8771 
 
8772 
  def __init__(self, transactionId=None,):
8773 
    self.transactionId = transactionId
8774 
 
8775 
  def read(self, iprot):
8776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8778 
      return
8779 
    iprot.readStructBegin()
8780 
    while True:
8781 
      (fname, ftype, fid) = iprot.readFieldBegin()
8782 
      if ftype == TType.STOP:
8783 
        break
8784 
      if fid == 1:
8785 
        if ftype == TType.I64:
8786 
          self.transactionId = iprot.readI64();
8787 
        else:
8788 
          iprot.skip(ftype)
8789 
      else:
8790 
        iprot.skip(ftype)
8791 
      iprot.readFieldEnd()
8792 
    iprot.readStructEnd()
8793 
 
8794 
  def write(self, oprot):
8795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8797 
      return
8798 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 8799 
    if self.transactionId is not None:
94 ashish 8800 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8801 
      oprot.writeI64(self.transactionId)
8802 
      oprot.writeFieldEnd()
8803 
    oprot.writeFieldStop()
8804 
    oprot.writeStructEnd()
8805 
 
3431 rajveer 8806 
  def validate(self):
8807 
    return
8808 
 
8809 
 
94 ashish 8810 
  def __repr__(self):
8811 
    L = ['%s=%r' % (key, value)
8812 
      for key, value in self.__dict__.iteritems()]
8813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8814 
 
8815 
  def __eq__(self, other):
8816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8817 
 
8818 
  def __ne__(self, other):
8819 
    return not (self == other)
8820 
 
8821 
class getTransactionStatus_result:
8822 
  """
8823 
  Attributes:
8824 
   - success
8825 
   - ex
8826 
  """
8827 
 
8828 
  thrift_spec = (
8829 
    (0, TType.I32, 'success', None, None, ), # 0
8830 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8831 
  )
8832 
 
8833 
  def __init__(self, success=None, ex=None,):
8834 
    self.success = success
8835 
    self.ex = ex
8836 
 
8837 
  def read(self, iprot):
8838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8840 
      return
8841 
    iprot.readStructBegin()
8842 
    while True:
8843 
      (fname, ftype, fid) = iprot.readFieldBegin()
8844 
      if ftype == TType.STOP:
8845 
        break
8846 
      if fid == 0:
8847 
        if ftype == TType.I32:
8848 
          self.success = iprot.readI32();
8849 
        else:
8850 
          iprot.skip(ftype)
8851 
      elif fid == 1:
8852 
        if ftype == TType.STRUCT:
8853 
          self.ex = TransactionServiceException()
8854 
          self.ex.read(iprot)
8855 
        else:
8856 
          iprot.skip(ftype)
8857 
      else:
8858 
        iprot.skip(ftype)
8859 
      iprot.readFieldEnd()
8860 
    iprot.readStructEnd()
8861 
 
8862 
  def write(self, oprot):
8863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8865 
      return
8866 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 8867 
    if self.success is not None:
94 ashish 8868 
      oprot.writeFieldBegin('success', TType.I32, 0)
8869 
      oprot.writeI32(self.success)
8870 
      oprot.writeFieldEnd()
3431 rajveer 8871 
    if self.ex is not None:
94 ashish 8872 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8873 
      self.ex.write(oprot)
8874 
      oprot.writeFieldEnd()
8875 
    oprot.writeFieldStop()
8876 
    oprot.writeStructEnd()
8877 
 
3431 rajveer 8878 
  def validate(self):
8879 
    return
8880 
 
8881 
 
94 ashish 8882 
  def __repr__(self):
8883 
    L = ['%s=%r' % (key, value)
8884 
      for key, value in self.__dict__.iteritems()]
8885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8886 
 
8887 
  def __eq__(self, other):
8888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8889 
 
8890 
  def __ne__(self, other):
8891 
    return not (self == other)
8892 
 
8893 
class changeTransactionStatus_args:
8894 
  """
8895 
  Attributes:
8896 
   - transactionId
8897 
   - status
8898 
   - description
5527 anupam.sin 8899 
   - pickUp
8900 
   - orderType
94 ashish 8901 
  """
8902 
 
8903 
  thrift_spec = (
8904 
    None, # 0
8905 
    (1, TType.I64, 'transactionId', None, None, ), # 1
8906 
    (2, TType.I32, 'status', None, None, ), # 2
8907 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 8908 
    (4, TType.I64, 'pickUp', None, None, ), # 4
8909 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 8910 
  )
8911 
 
5527 anupam.sin 8912 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 8913 
    self.transactionId = transactionId
8914 
    self.status = status
8915 
    self.description = description
5527 anupam.sin 8916 
    self.pickUp = pickUp
8917 
    self.orderType = orderType
94 ashish 8918 
 
8919 
  def read(self, iprot):
8920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8922 
      return
8923 
    iprot.readStructBegin()
8924 
    while True:
8925 
      (fname, ftype, fid) = iprot.readFieldBegin()
8926 
      if ftype == TType.STOP:
8927 
        break
8928 
      if fid == 1:
8929 
        if ftype == TType.I64:
8930 
          self.transactionId = iprot.readI64();
8931 
        else:
8932 
          iprot.skip(ftype)
8933 
      elif fid == 2:
8934 
        if ftype == TType.I32:
8935 
          self.status = iprot.readI32();
8936 
        else:
8937 
          iprot.skip(ftype)
8938 
      elif fid == 3:
8939 
        if ftype == TType.STRING:
8940 
          self.description = iprot.readString();
8941 
        else:
8942 
          iprot.skip(ftype)
5387 rajveer 8943 
      elif fid == 4:
5527 anupam.sin 8944 
        if ftype == TType.I64:
8945 
          self.pickUp = iprot.readI64();
5387 rajveer 8946 
        else:
8947 
          iprot.skip(ftype)
5527 anupam.sin 8948 
      elif fid == 5:
8949 
        if ftype == TType.I32:
8950 
          self.orderType = iprot.readI32();
8951 
        else:
8952 
          iprot.skip(ftype)
94 ashish 8953 
      else:
8954 
        iprot.skip(ftype)
8955 
      iprot.readFieldEnd()
8956 
    iprot.readStructEnd()
8957 
 
8958 
  def write(self, oprot):
8959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8961 
      return
8962 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 8963 
    if self.transactionId is not None:
94 ashish 8964 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
8965 
      oprot.writeI64(self.transactionId)
8966 
      oprot.writeFieldEnd()
3431 rajveer 8967 
    if self.status is not None:
94 ashish 8968 
      oprot.writeFieldBegin('status', TType.I32, 2)
8969 
      oprot.writeI32(self.status)
8970 
      oprot.writeFieldEnd()
3431 rajveer 8971 
    if self.description is not None:
94 ashish 8972 
      oprot.writeFieldBegin('description', TType.STRING, 3)
8973 
      oprot.writeString(self.description)
8974 
      oprot.writeFieldEnd()
5527 anupam.sin 8975 
    if self.pickUp is not None:
8976 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
8977 
      oprot.writeI64(self.pickUp)
5387 rajveer 8978 
      oprot.writeFieldEnd()
5527 anupam.sin 8979 
    if self.orderType is not None:
8980 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
8981 
      oprot.writeI32(self.orderType)
8982 
      oprot.writeFieldEnd()
94 ashish 8983 
    oprot.writeFieldStop()
8984 
    oprot.writeStructEnd()
8985 
 
3431 rajveer 8986 
  def validate(self):
8987 
    return
8988 
 
8989 
 
94 ashish 8990 
  def __repr__(self):
8991 
    L = ['%s=%r' % (key, value)
8992 
      for key, value in self.__dict__.iteritems()]
8993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8994 
 
8995 
  def __eq__(self, other):
8996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8997 
 
8998 
  def __ne__(self, other):
8999 
    return not (self == other)
9000 
 
9001 
class changeTransactionStatus_result:
9002 
  """
9003 
  Attributes:
9004 
   - success
9005 
   - ex
9006 
  """
9007 
 
9008 
  thrift_spec = (
9009 
    (0, TType.BOOL, 'success', None, None, ), # 0
9010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9011 
  )
9012 
 
9013 
  def __init__(self, success=None, ex=None,):
9014 
    self.success = success
9015 
    self.ex = ex
9016 
 
9017 
  def read(self, iprot):
9018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9020 
      return
9021 
    iprot.readStructBegin()
9022 
    while True:
9023 
      (fname, ftype, fid) = iprot.readFieldBegin()
9024 
      if ftype == TType.STOP:
9025 
        break
9026 
      if fid == 0:
9027 
        if ftype == TType.BOOL:
9028 
          self.success = iprot.readBool();
9029 
        else:
9030 
          iprot.skip(ftype)
9031 
      elif fid == 1:
9032 
        if ftype == TType.STRUCT:
9033 
          self.ex = TransactionServiceException()
9034 
          self.ex.read(iprot)
9035 
        else:
9036 
          iprot.skip(ftype)
9037 
      else:
9038 
        iprot.skip(ftype)
9039 
      iprot.readFieldEnd()
9040 
    iprot.readStructEnd()
9041 
 
9042 
  def write(self, oprot):
9043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9045 
      return
9046 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9047 
    if self.success is not None:
94 ashish 9048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9049 
      oprot.writeBool(self.success)
9050 
      oprot.writeFieldEnd()
3431 rajveer 9051 
    if self.ex is not None:
94 ashish 9052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9053 
      self.ex.write(oprot)
9054 
      oprot.writeFieldEnd()
9055 
    oprot.writeFieldStop()
9056 
    oprot.writeStructEnd()
9057 
 
3431 rajveer 9058 
  def validate(self):
9059 
    return
9060 
 
9061 
 
94 ashish 9062 
  def __repr__(self):
9063 
    L = ['%s=%r' % (key, value)
9064 
      for key, value in self.__dict__.iteritems()]
9065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9066 
 
9067 
  def __eq__(self, other):
9068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9069 
 
9070 
  def __ne__(self, other):
9071 
    return not (self == other)
9072 
 
1398 varun.gupt 9073 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9074 
  """
9075 
  Attributes:
9076 
   - transactionId
9077 
  """
9078 
 
9079 
  thrift_spec = (
9080 
    None, # 0
9081 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9082 
  )
9083 
 
9084 
  def __init__(self, transactionId=None,):
9085 
    self.transactionId = transactionId
9086 
 
9087 
  def read(self, iprot):
9088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9090 
      return
9091 
    iprot.readStructBegin()
9092 
    while True:
9093 
      (fname, ftype, fid) = iprot.readFieldBegin()
9094 
      if ftype == TType.STOP:
9095 
        break
9096 
      if fid == 1:
9097 
        if ftype == TType.I64:
9098 
          self.transactionId = iprot.readI64();
9099 
        else:
9100 
          iprot.skip(ftype)
9101 
      else:
9102 
        iprot.skip(ftype)
9103 
      iprot.readFieldEnd()
9104 
    iprot.readStructEnd()
9105 
 
9106 
  def write(self, oprot):
9107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9109 
      return
1398 varun.gupt 9110 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9111 
    if self.transactionId is not None:
1382 varun.gupt 9112 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9113 
      oprot.writeI64(self.transactionId)
9114 
      oprot.writeFieldEnd()
9115 
    oprot.writeFieldStop()
9116 
    oprot.writeStructEnd()
9117 
 
3431 rajveer 9118 
  def validate(self):
9119 
    return
9120 
 
9121 
 
1382 varun.gupt 9122 
  def __repr__(self):
9123 
    L = ['%s=%r' % (key, value)
9124 
      for key, value in self.__dict__.iteritems()]
9125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9126 
 
9127 
  def __eq__(self, other):
9128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9129 
 
9130 
  def __ne__(self, other):
9131 
    return not (self == other)
9132 
 
1398 varun.gupt 9133 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9134 
  """
9135 
  Attributes:
9136 
   - success
9137 
   - ex
9138 
  """
9139 
 
9140 
  thrift_spec = (
9141 
    (0, TType.BOOL, 'success', None, None, ), # 0
9142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9143 
  )
9144 
 
9145 
  def __init__(self, success=None, ex=None,):
9146 
    self.success = success
9147 
    self.ex = ex
9148 
 
9149 
  def read(self, iprot):
9150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9152 
      return
9153 
    iprot.readStructBegin()
9154 
    while True:
9155 
      (fname, ftype, fid) = iprot.readFieldBegin()
9156 
      if ftype == TType.STOP:
9157 
        break
9158 
      if fid == 0:
9159 
        if ftype == TType.BOOL:
9160 
          self.success = iprot.readBool();
9161 
        else:
9162 
          iprot.skip(ftype)
9163 
      elif fid == 1:
9164 
        if ftype == TType.STRUCT:
9165 
          self.ex = TransactionServiceException()
9166 
          self.ex.read(iprot)
9167 
        else:
9168 
          iprot.skip(ftype)
9169 
      else:
9170 
        iprot.skip(ftype)
9171 
      iprot.readFieldEnd()
9172 
    iprot.readStructEnd()
9173 
 
9174 
  def write(self, oprot):
9175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9177 
      return
1398 varun.gupt 9178 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9179 
    if self.success is not None:
1382 varun.gupt 9180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9181 
      oprot.writeBool(self.success)
9182 
      oprot.writeFieldEnd()
3431 rajveer 9183 
    if self.ex is not None:
1382 varun.gupt 9184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9185 
      self.ex.write(oprot)
9186 
      oprot.writeFieldEnd()
9187 
    oprot.writeFieldStop()
9188 
    oprot.writeStructEnd()
9189 
 
3431 rajveer 9190 
  def validate(self):
9191 
    return
9192 
 
9193 
 
1382 varun.gupt 9194 
  def __repr__(self):
9195 
    L = ['%s=%r' % (key, value)
9196 
      for key, value in self.__dict__.iteritems()]
9197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9198 
 
9199 
  def __eq__(self, other):
9200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9201 
 
9202 
  def __ne__(self, other):
9203 
    return not (self == other)
9204 
 
483 rajveer 9205 
class getAllOrders_args:
94 ashish 9206 
  """
9207 
  Attributes:
4801 anupam.sin 9208 
   - statuses
483 rajveer 9209 
   - from_date
9210 
   - to_date
9211 
   - warehouse_id
94 ashish 9212 
  """
9213 
 
9214 
  thrift_spec = (
9215 
    None, # 0
4801 anupam.sin 9216 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9217 
    (2, TType.I64, 'from_date', None, None, ), # 2
9218 
    (3, TType.I64, 'to_date', None, None, ), # 3
9219 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9220 
  )
9221 
 
4801 anupam.sin 9222 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9223 
    self.statuses = statuses
483 rajveer 9224 
    self.from_date = from_date
9225 
    self.to_date = to_date
9226 
    self.warehouse_id = warehouse_id
94 ashish 9227 
 
9228 
  def read(self, iprot):
9229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9231 
      return
9232 
    iprot.readStructBegin()
9233 
    while True:
9234 
      (fname, ftype, fid) = iprot.readFieldBegin()
9235 
      if ftype == TType.STOP:
9236 
        break
9237 
      if fid == 1:
4801 anupam.sin 9238 
        if ftype == TType.LIST:
9239 
          self.statuses = []
6031 rajveer 9240 
          (_etype80, _size77) = iprot.readListBegin()
9241 
          for _i81 in xrange(_size77):
9242 
            _elem82 = iprot.readI32();
9243 
            self.statuses.append(_elem82)
4801 anupam.sin 9244 
          iprot.readListEnd()
94 ashish 9245 
        else:
9246 
          iprot.skip(ftype)
483 rajveer 9247 
      elif fid == 2:
9248 
        if ftype == TType.I64:
9249 
          self.from_date = iprot.readI64();
94 ashish 9250 
        else:
9251 
          iprot.skip(ftype)
483 rajveer 9252 
      elif fid == 3:
9253 
        if ftype == TType.I64:
9254 
          self.to_date = iprot.readI64();
94 ashish 9255 
        else:
9256 
          iprot.skip(ftype)
483 rajveer 9257 
      elif fid == 4:
94 ashish 9258 
        if ftype == TType.I64:
483 rajveer 9259 
          self.warehouse_id = iprot.readI64();
94 ashish 9260 
        else:
9261 
          iprot.skip(ftype)
9262 
      else:
9263 
        iprot.skip(ftype)
9264 
      iprot.readFieldEnd()
9265 
    iprot.readStructEnd()
9266 
 
9267 
  def write(self, oprot):
9268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9270 
      return
483 rajveer 9271 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9272 
    if self.statuses is not None:
9273 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9274 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9275 
      for iter83 in self.statuses:
9276 
        oprot.writeI32(iter83)
4801 anupam.sin 9277 
      oprot.writeListEnd()
94 ashish 9278 
      oprot.writeFieldEnd()
3431 rajveer 9279 
    if self.from_date is not None:
483 rajveer 9280 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9281 
      oprot.writeI64(self.from_date)
94 ashish 9282 
      oprot.writeFieldEnd()
3431 rajveer 9283 
    if self.to_date is not None:
483 rajveer 9284 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9285 
      oprot.writeI64(self.to_date)
94 ashish 9286 
      oprot.writeFieldEnd()
3431 rajveer 9287 
    if self.warehouse_id is not None:
483 rajveer 9288 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9289 
      oprot.writeI64(self.warehouse_id)
94 ashish 9290 
      oprot.writeFieldEnd()
9291 
    oprot.writeFieldStop()
9292 
    oprot.writeStructEnd()
9293 
 
3431 rajveer 9294 
  def validate(self):
9295 
    return
9296 
 
9297 
 
94 ashish 9298 
  def __repr__(self):
9299 
    L = ['%s=%r' % (key, value)
9300 
      for key, value in self.__dict__.iteritems()]
9301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9302 
 
9303 
  def __eq__(self, other):
9304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9305 
 
9306 
  def __ne__(self, other):
9307 
    return not (self == other)
9308 
 
483 rajveer 9309 
class getAllOrders_result:
94 ashish 9310 
  """
9311 
  Attributes:
9312 
   - success
9313 
   - ex
9314 
  """
9315 
 
9316 
  thrift_spec = (
483 rajveer 9317 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9318 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9319 
  )
9320 
 
9321 
  def __init__(self, success=None, ex=None,):
9322 
    self.success = success
9323 
    self.ex = ex
9324 
 
9325 
  def read(self, iprot):
9326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9328 
      return
9329 
    iprot.readStructBegin()
9330 
    while True:
9331 
      (fname, ftype, fid) = iprot.readFieldBegin()
9332 
      if ftype == TType.STOP:
9333 
        break
9334 
      if fid == 0:
483 rajveer 9335 
        if ftype == TType.LIST:
9336 
          self.success = []
6031 rajveer 9337 
          (_etype87, _size84) = iprot.readListBegin()
9338 
          for _i88 in xrange(_size84):
9339 
            _elem89 = Order()
9340 
            _elem89.read(iprot)
9341 
            self.success.append(_elem89)
483 rajveer 9342 
          iprot.readListEnd()
94 ashish 9343 
        else:
9344 
          iprot.skip(ftype)
9345 
      elif fid == 1:
9346 
        if ftype == TType.STRUCT:
9347 
          self.ex = TransactionServiceException()
9348 
          self.ex.read(iprot)
9349 
        else:
9350 
          iprot.skip(ftype)
9351 
      else:
9352 
        iprot.skip(ftype)
9353 
      iprot.readFieldEnd()
9354 
    iprot.readStructEnd()
9355 
 
9356 
  def write(self, oprot):
9357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9359 
      return
483 rajveer 9360 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9361 
    if self.success is not None:
483 rajveer 9362 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9363 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9364 
      for iter90 in self.success:
9365 
        iter90.write(oprot)
483 rajveer 9366 
      oprot.writeListEnd()
94 ashish 9367 
      oprot.writeFieldEnd()
3431 rajveer 9368 
    if self.ex is not None:
94 ashish 9369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9370 
      self.ex.write(oprot)
9371 
      oprot.writeFieldEnd()
9372 
    oprot.writeFieldStop()
9373 
    oprot.writeStructEnd()
9374 
 
3431 rajveer 9375 
  def validate(self):
9376 
    return
9377 
 
9378 
 
94 ashish 9379 
  def __repr__(self):
9380 
    L = ['%s=%r' % (key, value)
9381 
      for key, value in self.__dict__.iteritems()]
9382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9383 
 
9384 
  def __eq__(self, other):
9385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9386 
 
9387 
  def __ne__(self, other):
9388 
    return not (self == other)
9389 
 
4133 chandransh 9390 
class getOrdersInBatch_args:
9391 
  """
9392 
  Attributes:
9393 
   - statuses
9394 
   - offset
9395 
   - limit
9396 
   - warehouse_id
9397 
  """
9398 
 
9399 
  thrift_spec = (
9400 
    None, # 0
9401 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9402 
    (2, TType.I64, 'offset', None, None, ), # 2
9403 
    (3, TType.I64, 'limit', None, None, ), # 3
9404 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9405 
  )
9406 
 
9407 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9408 
    self.statuses = statuses
9409 
    self.offset = offset
9410 
    self.limit = limit
9411 
    self.warehouse_id = warehouse_id
9412 
 
9413 
  def read(self, iprot):
9414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9416 
      return
9417 
    iprot.readStructBegin()
9418 
    while True:
9419 
      (fname, ftype, fid) = iprot.readFieldBegin()
9420 
      if ftype == TType.STOP:
9421 
        break
9422 
      if fid == 1:
9423 
        if ftype == TType.LIST:
9424 
          self.statuses = []
6031 rajveer 9425 
          (_etype94, _size91) = iprot.readListBegin()
9426 
          for _i95 in xrange(_size91):
9427 
            _elem96 = iprot.readI32();
9428 
            self.statuses.append(_elem96)
4133 chandransh 9429 
          iprot.readListEnd()
9430 
        else:
9431 
          iprot.skip(ftype)
9432 
      elif fid == 2:
9433 
        if ftype == TType.I64:
9434 
          self.offset = iprot.readI64();
9435 
        else:
9436 
          iprot.skip(ftype)
9437 
      elif fid == 3:
9438 
        if ftype == TType.I64:
9439 
          self.limit = iprot.readI64();
9440 
        else:
9441 
          iprot.skip(ftype)
9442 
      elif fid == 4:
9443 
        if ftype == TType.I64:
9444 
          self.warehouse_id = iprot.readI64();
9445 
        else:
9446 
          iprot.skip(ftype)
9447 
      else:
9448 
        iprot.skip(ftype)
9449 
      iprot.readFieldEnd()
9450 
    iprot.readStructEnd()
9451 
 
9452 
  def write(self, oprot):
9453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9455 
      return
9456 
    oprot.writeStructBegin('getOrdersInBatch_args')
9457 
    if self.statuses is not None:
9458 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9459 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9460 
      for iter97 in self.statuses:
9461 
        oprot.writeI32(iter97)
4133 chandransh 9462 
      oprot.writeListEnd()
9463 
      oprot.writeFieldEnd()
9464 
    if self.offset is not None:
9465 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9466 
      oprot.writeI64(self.offset)
9467 
      oprot.writeFieldEnd()
9468 
    if self.limit is not None:
9469 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9470 
      oprot.writeI64(self.limit)
9471 
      oprot.writeFieldEnd()
9472 
    if self.warehouse_id is not None:
9473 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9474 
      oprot.writeI64(self.warehouse_id)
9475 
      oprot.writeFieldEnd()
9476 
    oprot.writeFieldStop()
9477 
    oprot.writeStructEnd()
9478 
 
9479 
  def validate(self):
9480 
    return
9481 
 
9482 
 
9483 
  def __repr__(self):
9484 
    L = ['%s=%r' % (key, value)
9485 
      for key, value in self.__dict__.iteritems()]
9486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9487 
 
9488 
  def __eq__(self, other):
9489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9490 
 
9491 
  def __ne__(self, other):
9492 
    return not (self == other)
9493 
 
9494 
class getOrdersInBatch_result:
9495 
  """
9496 
  Attributes:
9497 
   - success
9498 
   - ex
9499 
  """
9500 
 
9501 
  thrift_spec = (
9502 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9504 
  )
9505 
 
9506 
  def __init__(self, success=None, ex=None,):
9507 
    self.success = success
9508 
    self.ex = ex
9509 
 
9510 
  def read(self, iprot):
9511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9513 
      return
9514 
    iprot.readStructBegin()
9515 
    while True:
9516 
      (fname, ftype, fid) = iprot.readFieldBegin()
9517 
      if ftype == TType.STOP:
9518 
        break
9519 
      if fid == 0:
9520 
        if ftype == TType.LIST:
9521 
          self.success = []
6031 rajveer 9522 
          (_etype101, _size98) = iprot.readListBegin()
9523 
          for _i102 in xrange(_size98):
9524 
            _elem103 = Order()
9525 
            _elem103.read(iprot)
9526 
            self.success.append(_elem103)
4133 chandransh 9527 
          iprot.readListEnd()
9528 
        else:
9529 
          iprot.skip(ftype)
9530 
      elif fid == 1:
9531 
        if ftype == TType.STRUCT:
9532 
          self.ex = TransactionServiceException()
9533 
          self.ex.read(iprot)
9534 
        else:
9535 
          iprot.skip(ftype)
9536 
      else:
9537 
        iprot.skip(ftype)
9538 
      iprot.readFieldEnd()
9539 
    iprot.readStructEnd()
9540 
 
9541 
  def write(self, oprot):
9542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9544 
      return
9545 
    oprot.writeStructBegin('getOrdersInBatch_result')
9546 
    if self.success is not None:
9547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9548 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9549 
      for iter104 in self.success:
9550 
        iter104.write(oprot)
4133 chandransh 9551 
      oprot.writeListEnd()
9552 
      oprot.writeFieldEnd()
9553 
    if self.ex is not None:
9554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9555 
      self.ex.write(oprot)
9556 
      oprot.writeFieldEnd()
9557 
    oprot.writeFieldStop()
9558 
    oprot.writeStructEnd()
9559 
 
9560 
  def validate(self):
9561 
    return
9562 
 
9563 
 
9564 
  def __repr__(self):
9565 
    L = ['%s=%r' % (key, value)
9566 
      for key, value in self.__dict__.iteritems()]
9567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9568 
 
9569 
  def __eq__(self, other):
9570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9571 
 
9572 
  def __ne__(self, other):
9573 
    return not (self == other)
9574 
 
9575 
class getOrderCount_args:
9576 
  """
9577 
  Attributes:
9578 
   - statuses
9579 
   - warehouseId
9580 
  """
9581 
 
9582 
  thrift_spec = (
9583 
    None, # 0
9584 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9585 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9586 
  )
9587 
 
9588 
  def __init__(self, statuses=None, warehouseId=None,):
9589 
    self.statuses = statuses
9590 
    self.warehouseId = warehouseId
9591 
 
9592 
  def read(self, iprot):
9593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9595 
      return
9596 
    iprot.readStructBegin()
9597 
    while True:
9598 
      (fname, ftype, fid) = iprot.readFieldBegin()
9599 
      if ftype == TType.STOP:
9600 
        break
9601 
      if fid == 1:
9602 
        if ftype == TType.LIST:
9603 
          self.statuses = []
6031 rajveer 9604 
          (_etype108, _size105) = iprot.readListBegin()
9605 
          for _i109 in xrange(_size105):
9606 
            _elem110 = iprot.readI32();
9607 
            self.statuses.append(_elem110)
4133 chandransh 9608 
          iprot.readListEnd()
9609 
        else:
9610 
          iprot.skip(ftype)
9611 
      elif fid == 2:
9612 
        if ftype == TType.I64:
9613 
          self.warehouseId = iprot.readI64();
9614 
        else:
9615 
          iprot.skip(ftype)
9616 
      else:
9617 
        iprot.skip(ftype)
9618 
      iprot.readFieldEnd()
9619 
    iprot.readStructEnd()
9620 
 
9621 
  def write(self, oprot):
9622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9624 
      return
9625 
    oprot.writeStructBegin('getOrderCount_args')
9626 
    if self.statuses is not None:
9627 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9628 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 9629 
      for iter111 in self.statuses:
9630 
        oprot.writeI32(iter111)
4133 chandransh 9631 
      oprot.writeListEnd()
9632 
      oprot.writeFieldEnd()
9633 
    if self.warehouseId is not None:
9634 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9635 
      oprot.writeI64(self.warehouseId)
9636 
      oprot.writeFieldEnd()
9637 
    oprot.writeFieldStop()
9638 
    oprot.writeStructEnd()
9639 
 
9640 
  def validate(self):
9641 
    return
9642 
 
9643 
 
9644 
  def __repr__(self):
9645 
    L = ['%s=%r' % (key, value)
9646 
      for key, value in self.__dict__.iteritems()]
9647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9648 
 
9649 
  def __eq__(self, other):
9650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9651 
 
9652 
  def __ne__(self, other):
9653 
    return not (self == other)
9654 
 
9655 
class getOrderCount_result:
9656 
  """
9657 
  Attributes:
9658 
   - success
9659 
   - ex
9660 
  """
9661 
 
9662 
  thrift_spec = (
9663 
    (0, TType.I32, 'success', None, None, ), # 0
9664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9665 
  )
9666 
 
9667 
  def __init__(self, success=None, ex=None,):
9668 
    self.success = success
9669 
    self.ex = ex
9670 
 
9671 
  def read(self, iprot):
9672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9674 
      return
9675 
    iprot.readStructBegin()
9676 
    while True:
9677 
      (fname, ftype, fid) = iprot.readFieldBegin()
9678 
      if ftype == TType.STOP:
9679 
        break
9680 
      if fid == 0:
9681 
        if ftype == TType.I32:
9682 
          self.success = iprot.readI32();
9683 
        else:
9684 
          iprot.skip(ftype)
9685 
      elif fid == 1:
9686 
        if ftype == TType.STRUCT:
9687 
          self.ex = TransactionServiceException()
9688 
          self.ex.read(iprot)
9689 
        else:
9690 
          iprot.skip(ftype)
9691 
      else:
9692 
        iprot.skip(ftype)
9693 
      iprot.readFieldEnd()
9694 
    iprot.readStructEnd()
9695 
 
9696 
  def write(self, oprot):
9697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9699 
      return
9700 
    oprot.writeStructBegin('getOrderCount_result')
9701 
    if self.success is not None:
9702 
      oprot.writeFieldBegin('success', TType.I32, 0)
9703 
      oprot.writeI32(self.success)
9704 
      oprot.writeFieldEnd()
9705 
    if self.ex is not None:
9706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9707 
      self.ex.write(oprot)
9708 
      oprot.writeFieldEnd()
9709 
    oprot.writeFieldStop()
9710 
    oprot.writeStructEnd()
9711 
 
9712 
  def validate(self):
9713 
    return
9714 
 
9715 
 
9716 
  def __repr__(self):
9717 
    L = ['%s=%r' % (key, value)
9718 
      for key, value in self.__dict__.iteritems()]
9719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9720 
 
9721 
  def __eq__(self, other):
9722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9723 
 
9724 
  def __ne__(self, other):
9725 
    return not (self == other)
9726 
 
999 varun.gupt 9727 
class getOrdersByBillingDate_args:
9728 
  """
9729 
  Attributes:
9730 
   - status
9731 
   - start_billing_date
9732 
   - end_billing_date
9733 
   - warehouse_id
9734 
  """
9735 
 
9736 
  thrift_spec = (
9737 
    None, # 0
9738 
    (1, TType.I32, 'status', None, None, ), # 1
9739 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
9740 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
9741 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9742 
  )
9743 
 
9744 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
9745 
    self.status = status
9746 
    self.start_billing_date = start_billing_date
9747 
    self.end_billing_date = end_billing_date
9748 
    self.warehouse_id = warehouse_id
9749 
 
9750 
  def read(self, iprot):
9751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9753 
      return
9754 
    iprot.readStructBegin()
9755 
    while True:
9756 
      (fname, ftype, fid) = iprot.readFieldBegin()
9757 
      if ftype == TType.STOP:
9758 
        break
9759 
      if fid == 1:
9760 
        if ftype == TType.I32:
9761 
          self.status = iprot.readI32();
9762 
        else:
9763 
          iprot.skip(ftype)
9764 
      elif fid == 2:
9765 
        if ftype == TType.I64:
9766 
          self.start_billing_date = iprot.readI64();
9767 
        else:
9768 
          iprot.skip(ftype)
9769 
      elif fid == 3:
9770 
        if ftype == TType.I64:
9771 
          self.end_billing_date = iprot.readI64();
9772 
        else:
9773 
          iprot.skip(ftype)
9774 
      elif fid == 4:
9775 
        if ftype == TType.I64:
9776 
          self.warehouse_id = iprot.readI64();
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
9788 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 9789 
    if self.status is not None:
999 varun.gupt 9790 
      oprot.writeFieldBegin('status', TType.I32, 1)
9791 
      oprot.writeI32(self.status)
9792 
      oprot.writeFieldEnd()
3431 rajveer 9793 
    if self.start_billing_date is not None:
999 varun.gupt 9794 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
9795 
      oprot.writeI64(self.start_billing_date)
9796 
      oprot.writeFieldEnd()
3431 rajveer 9797 
    if self.end_billing_date is not None:
999 varun.gupt 9798 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
9799 
      oprot.writeI64(self.end_billing_date)
9800 
      oprot.writeFieldEnd()
3431 rajveer 9801 
    if self.warehouse_id is not None:
999 varun.gupt 9802 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9803 
      oprot.writeI64(self.warehouse_id)
9804 
      oprot.writeFieldEnd()
9805 
    oprot.writeFieldStop()
9806 
    oprot.writeStructEnd()
9807 
 
3431 rajveer 9808 
  def validate(self):
9809 
    return
9810 
 
9811 
 
999 varun.gupt 9812 
  def __repr__(self):
9813 
    L = ['%s=%r' % (key, value)
9814 
      for key, value in self.__dict__.iteritems()]
9815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9816 
 
9817 
  def __eq__(self, other):
9818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9819 
 
9820 
  def __ne__(self, other):
9821 
    return not (self == other)
9822 
 
9823 
class getOrdersByBillingDate_result:
9824 
  """
9825 
  Attributes:
9826 
   - success
9827 
   - ex
9828 
  """
9829 
 
9830 
  thrift_spec = (
9831 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9832 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9833 
  )
9834 
 
9835 
  def __init__(self, success=None, ex=None,):
9836 
    self.success = success
9837 
    self.ex = ex
9838 
 
9839 
  def read(self, iprot):
9840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9842 
      return
9843 
    iprot.readStructBegin()
9844 
    while True:
9845 
      (fname, ftype, fid) = iprot.readFieldBegin()
9846 
      if ftype == TType.STOP:
9847 
        break
9848 
      if fid == 0:
9849 
        if ftype == TType.LIST:
9850 
          self.success = []
6031 rajveer 9851 
          (_etype115, _size112) = iprot.readListBegin()
9852 
          for _i116 in xrange(_size112):
9853 
            _elem117 = Order()
9854 
            _elem117.read(iprot)
9855 
            self.success.append(_elem117)
999 varun.gupt 9856 
          iprot.readListEnd()
9857 
        else:
9858 
          iprot.skip(ftype)
9859 
      elif fid == 1:
9860 
        if ftype == TType.STRUCT:
9861 
          self.ex = TransactionServiceException()
9862 
          self.ex.read(iprot)
9863 
        else:
9864 
          iprot.skip(ftype)
9865 
      else:
9866 
        iprot.skip(ftype)
9867 
      iprot.readFieldEnd()
9868 
    iprot.readStructEnd()
9869 
 
9870 
  def write(self, oprot):
9871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9873 
      return
9874 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 9875 
    if self.success is not None:
999 varun.gupt 9876 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9877 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 9878 
      for iter118 in self.success:
9879 
        iter118.write(oprot)
999 varun.gupt 9880 
      oprot.writeListEnd()
9881 
      oprot.writeFieldEnd()
3431 rajveer 9882 
    if self.ex is not None:
999 varun.gupt 9883 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9884 
      self.ex.write(oprot)
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
3431 rajveer 9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
999 varun.gupt 9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
3427 chandransh 9904 
class getOrdersByShippingDate_args:
9905 
  """
9906 
  Attributes:
9907 
   - fromShippingDate
9908 
   - toShippingDate
9909 
   - providerId
9910 
   - warehouseId
3451 chandransh 9911 
   - cod
3427 chandransh 9912 
  """
9913 
 
9914 
  thrift_spec = (
9915 
    None, # 0
9916 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
9917 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
9918 
    (3, TType.I64, 'providerId', None, None, ), # 3
9919 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 9920 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 9921 
  )
9922 
 
3451 chandransh 9923 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 9924 
    self.fromShippingDate = fromShippingDate
9925 
    self.toShippingDate = toShippingDate
9926 
    self.providerId = providerId
9927 
    self.warehouseId = warehouseId
3451 chandransh 9928 
    self.cod = cod
3427 chandransh 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.I64:
9941 
          self.fromShippingDate = iprot.readI64();
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      elif fid == 2:
9945 
        if ftype == TType.I64:
9946 
          self.toShippingDate = iprot.readI64();
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      elif fid == 3:
9950 
        if ftype == TType.I64:
9951 
          self.providerId = iprot.readI64();
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      elif fid == 4:
9955 
        if ftype == TType.I64:
9956 
          self.warehouseId = iprot.readI64();
9957 
        else:
9958 
          iprot.skip(ftype)
3451 chandransh 9959 
      elif fid == 5:
9960 
        if ftype == TType.BOOL:
9961 
          self.cod = iprot.readBool();
9962 
        else:
9963 
          iprot.skip(ftype)
3427 chandransh 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('getOrdersByShippingDate_args')
3431 rajveer 9974 
    if self.fromShippingDate is not None:
3427 chandransh 9975 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
9976 
      oprot.writeI64(self.fromShippingDate)
9977 
      oprot.writeFieldEnd()
3431 rajveer 9978 
    if self.toShippingDate is not None:
3427 chandransh 9979 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
9980 
      oprot.writeI64(self.toShippingDate)
9981 
      oprot.writeFieldEnd()
3431 rajveer 9982 
    if self.providerId is not None:
3427 chandransh 9983 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
9984 
      oprot.writeI64(self.providerId)
9985 
      oprot.writeFieldEnd()
3431 rajveer 9986 
    if self.warehouseId is not None:
3427 chandransh 9987 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
9988 
      oprot.writeI64(self.warehouseId)
9989 
      oprot.writeFieldEnd()
3451 chandransh 9990 
    if self.cod is not None:
9991 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
9992 
      oprot.writeBool(self.cod)
9993 
      oprot.writeFieldEnd()
3427 chandransh 9994 
    oprot.writeFieldStop()
9995 
    oprot.writeStructEnd()
9996 
 
3431 rajveer 9997 
  def validate(self):
9998 
    return
9999 
 
10000 
 
3427 chandransh 10001 
  def __repr__(self):
10002 
    L = ['%s=%r' % (key, value)
10003 
      for key, value in self.__dict__.iteritems()]
10004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10005 
 
10006 
  def __eq__(self, other):
10007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10008 
 
10009 
  def __ne__(self, other):
10010 
    return not (self == other)
10011 
 
10012 
class getOrdersByShippingDate_result:
10013 
  """
10014 
  Attributes:
10015 
   - success
10016 
   - ex
10017 
  """
10018 
 
10019 
  thrift_spec = (
10020 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10021 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10022 
  )
10023 
 
10024 
  def __init__(self, success=None, ex=None,):
10025 
    self.success = success
10026 
    self.ex = ex
10027 
 
10028 
  def read(self, iprot):
10029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10031 
      return
10032 
    iprot.readStructBegin()
10033 
    while True:
10034 
      (fname, ftype, fid) = iprot.readFieldBegin()
10035 
      if ftype == TType.STOP:
10036 
        break
10037 
      if fid == 0:
10038 
        if ftype == TType.LIST:
10039 
          self.success = []
6031 rajveer 10040 
          (_etype122, _size119) = iprot.readListBegin()
10041 
          for _i123 in xrange(_size119):
10042 
            _elem124 = Order()
10043 
            _elem124.read(iprot)
10044 
            self.success.append(_elem124)
3427 chandransh 10045 
          iprot.readListEnd()
10046 
        else:
10047 
          iprot.skip(ftype)
10048 
      elif fid == 1:
10049 
        if ftype == TType.STRUCT:
10050 
          self.ex = TransactionServiceException()
10051 
          self.ex.read(iprot)
10052 
        else:
10053 
          iprot.skip(ftype)
10054 
      else:
10055 
        iprot.skip(ftype)
10056 
      iprot.readFieldEnd()
10057 
    iprot.readStructEnd()
10058 
 
10059 
  def write(self, oprot):
10060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10062 
      return
10063 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10064 
    if self.success is not None:
3427 chandransh 10065 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10066 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10067 
      for iter125 in self.success:
10068 
        iter125.write(oprot)
3427 chandransh 10069 
      oprot.writeListEnd()
10070 
      oprot.writeFieldEnd()
3431 rajveer 10071 
    if self.ex is not None:
3427 chandransh 10072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10073 
      self.ex.write(oprot)
10074 
      oprot.writeFieldEnd()
10075 
    oprot.writeFieldStop()
10076 
    oprot.writeStructEnd()
10077 
 
3431 rajveer 10078 
  def validate(self):
10079 
    return
10080 
 
10081 
 
3427 chandransh 10082 
  def __repr__(self):
10083 
    L = ['%s=%r' % (key, value)
10084 
      for key, value in self.__dict__.iteritems()]
10085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10086 
 
10087 
  def __eq__(self, other):
10088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10089 
 
10090 
  def __ne__(self, other):
10091 
    return not (self == other)
10092 
 
1382 varun.gupt 10093 
class getReturnableOrdersForCustomer_args:
10094 
  """
10095 
  Attributes:
10096 
   - customer_id
10097 
   - limit
10098 
  """
10099 
 
10100 
  thrift_spec = (
10101 
    None, # 0
10102 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10103 
    (2, TType.I64, 'limit', None, None, ), # 2
10104 
  )
10105 
 
10106 
  def __init__(self, customer_id=None, limit=None,):
10107 
    self.customer_id = customer_id
10108 
    self.limit = limit
10109 
 
10110 
  def read(self, iprot):
10111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10113 
      return
10114 
    iprot.readStructBegin()
10115 
    while True:
10116 
      (fname, ftype, fid) = iprot.readFieldBegin()
10117 
      if ftype == TType.STOP:
10118 
        break
10119 
      if fid == 1:
10120 
        if ftype == TType.I64:
10121 
          self.customer_id = iprot.readI64();
10122 
        else:
10123 
          iprot.skip(ftype)
10124 
      elif fid == 2:
10125 
        if ftype == TType.I64:
10126 
          self.limit = iprot.readI64();
10127 
        else:
10128 
          iprot.skip(ftype)
10129 
      else:
10130 
        iprot.skip(ftype)
10131 
      iprot.readFieldEnd()
10132 
    iprot.readStructEnd()
10133 
 
10134 
  def write(self, oprot):
10135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10137 
      return
10138 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10139 
    if self.customer_id is not None:
1382 varun.gupt 10140 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10141 
      oprot.writeI64(self.customer_id)
10142 
      oprot.writeFieldEnd()
3431 rajveer 10143 
    if self.limit is not None:
1382 varun.gupt 10144 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10145 
      oprot.writeI64(self.limit)
10146 
      oprot.writeFieldEnd()
10147 
    oprot.writeFieldStop()
10148 
    oprot.writeStructEnd()
10149 
 
3431 rajveer 10150 
  def validate(self):
10151 
    return
10152 
 
10153 
 
1382 varun.gupt 10154 
  def __repr__(self):
10155 
    L = ['%s=%r' % (key, value)
10156 
      for key, value in self.__dict__.iteritems()]
10157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10158 
 
10159 
  def __eq__(self, other):
10160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10161 
 
10162 
  def __ne__(self, other):
10163 
    return not (self == other)
10164 
 
10165 
class getReturnableOrdersForCustomer_result:
10166 
  """
10167 
  Attributes:
10168 
   - success
10169 
   - ex
10170 
  """
10171 
 
10172 
  thrift_spec = (
10173 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10175 
  )
10176 
 
10177 
  def __init__(self, success=None, ex=None,):
10178 
    self.success = success
10179 
    self.ex = ex
10180 
 
10181 
  def read(self, iprot):
10182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10184 
      return
10185 
    iprot.readStructBegin()
10186 
    while True:
10187 
      (fname, ftype, fid) = iprot.readFieldBegin()
10188 
      if ftype == TType.STOP:
10189 
        break
10190 
      if fid == 0:
10191 
        if ftype == TType.LIST:
10192 
          self.success = []
6031 rajveer 10193 
          (_etype129, _size126) = iprot.readListBegin()
10194 
          for _i130 in xrange(_size126):
10195 
            _elem131 = iprot.readI64();
10196 
            self.success.append(_elem131)
1382 varun.gupt 10197 
          iprot.readListEnd()
10198 
        else:
10199 
          iprot.skip(ftype)
10200 
      elif fid == 1:
10201 
        if ftype == TType.STRUCT:
10202 
          self.ex = TransactionServiceException()
10203 
          self.ex.read(iprot)
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      else:
10207 
        iprot.skip(ftype)
10208 
      iprot.readFieldEnd()
10209 
    iprot.readStructEnd()
10210 
 
10211 
  def write(self, oprot):
10212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10214 
      return
10215 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10216 
    if self.success is not None:
1382 varun.gupt 10217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10218 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10219 
      for iter132 in self.success:
10220 
        oprot.writeI64(iter132)
1382 varun.gupt 10221 
      oprot.writeListEnd()
10222 
      oprot.writeFieldEnd()
3431 rajveer 10223 
    if self.ex is not None:
1382 varun.gupt 10224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10225 
      self.ex.write(oprot)
10226 
      oprot.writeFieldEnd()
10227 
    oprot.writeFieldStop()
10228 
    oprot.writeStructEnd()
10229 
 
3431 rajveer 10230 
  def validate(self):
10231 
    return
10232 
 
10233 
 
1382 varun.gupt 10234 
  def __repr__(self):
10235 
    L = ['%s=%r' % (key, value)
10236 
      for key, value in self.__dict__.iteritems()]
10237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10238 
 
10239 
  def __eq__(self, other):
10240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10241 
 
10242 
  def __ne__(self, other):
10243 
    return not (self == other)
10244 
 
10245 
class getCancellableOrdersForCustomer_args:
10246 
  """
10247 
  Attributes:
10248 
   - customer_id
10249 
   - limit
10250 
  """
10251 
 
10252 
  thrift_spec = (
10253 
    None, # 0
10254 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10255 
    (2, TType.I64, 'limit', None, None, ), # 2
10256 
  )
10257 
 
10258 
  def __init__(self, customer_id=None, limit=None,):
10259 
    self.customer_id = customer_id
10260 
    self.limit = limit
10261 
 
10262 
  def read(self, iprot):
10263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10265 
      return
10266 
    iprot.readStructBegin()
10267 
    while True:
10268 
      (fname, ftype, fid) = iprot.readFieldBegin()
10269 
      if ftype == TType.STOP:
10270 
        break
10271 
      if fid == 1:
10272 
        if ftype == TType.I64:
10273 
          self.customer_id = iprot.readI64();
10274 
        else:
10275 
          iprot.skip(ftype)
10276 
      elif fid == 2:
10277 
        if ftype == TType.I64:
10278 
          self.limit = iprot.readI64();
10279 
        else:
10280 
          iprot.skip(ftype)
10281 
      else:
10282 
        iprot.skip(ftype)
10283 
      iprot.readFieldEnd()
10284 
    iprot.readStructEnd()
10285 
 
10286 
  def write(self, oprot):
10287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10289 
      return
10290 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10291 
    if self.customer_id is not None:
1382 varun.gupt 10292 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10293 
      oprot.writeI64(self.customer_id)
10294 
      oprot.writeFieldEnd()
3431 rajveer 10295 
    if self.limit is not None:
1382 varun.gupt 10296 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10297 
      oprot.writeI64(self.limit)
10298 
      oprot.writeFieldEnd()
10299 
    oprot.writeFieldStop()
10300 
    oprot.writeStructEnd()
10301 
 
3431 rajveer 10302 
  def validate(self):
10303 
    return
10304 
 
10305 
 
1382 varun.gupt 10306 
  def __repr__(self):
10307 
    L = ['%s=%r' % (key, value)
10308 
      for key, value in self.__dict__.iteritems()]
10309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10310 
 
10311 
  def __eq__(self, other):
10312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10313 
 
10314 
  def __ne__(self, other):
10315 
    return not (self == other)
10316 
 
10317 
class getCancellableOrdersForCustomer_result:
10318 
  """
10319 
  Attributes:
10320 
   - success
10321 
   - ex
10322 
  """
10323 
 
10324 
  thrift_spec = (
10325 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10327 
  )
10328 
 
10329 
  def __init__(self, success=None, ex=None,):
10330 
    self.success = success
10331 
    self.ex = ex
10332 
 
10333 
  def read(self, iprot):
10334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10336 
      return
10337 
    iprot.readStructBegin()
10338 
    while True:
10339 
      (fname, ftype, fid) = iprot.readFieldBegin()
10340 
      if ftype == TType.STOP:
10341 
        break
10342 
      if fid == 0:
10343 
        if ftype == TType.LIST:
10344 
          self.success = []
6031 rajveer 10345 
          (_etype136, _size133) = iprot.readListBegin()
10346 
          for _i137 in xrange(_size133):
10347 
            _elem138 = iprot.readI64();
10348 
            self.success.append(_elem138)
1382 varun.gupt 10349 
          iprot.readListEnd()
10350 
        else:
10351 
          iprot.skip(ftype)
10352 
      elif fid == 1:
10353 
        if ftype == TType.STRUCT:
10354 
          self.ex = TransactionServiceException()
10355 
          self.ex.read(iprot)
10356 
        else:
10357 
          iprot.skip(ftype)
10358 
      else:
10359 
        iprot.skip(ftype)
10360 
      iprot.readFieldEnd()
10361 
    iprot.readStructEnd()
10362 
 
10363 
  def write(self, oprot):
10364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10366 
      return
10367 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10368 
    if self.success is not None:
1382 varun.gupt 10369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10370 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 10371 
      for iter139 in self.success:
10372 
        oprot.writeI64(iter139)
1382 varun.gupt 10373 
      oprot.writeListEnd()
10374 
      oprot.writeFieldEnd()
3431 rajveer 10375 
    if self.ex is not None:
1382 varun.gupt 10376 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10377 
      self.ex.write(oprot)
10378 
      oprot.writeFieldEnd()
10379 
    oprot.writeFieldStop()
10380 
    oprot.writeStructEnd()
10381 
 
3431 rajveer 10382 
  def validate(self):
10383 
    return
10384 
 
10385 
 
1382 varun.gupt 10386 
  def __repr__(self):
10387 
    L = ['%s=%r' % (key, value)
10388 
      for key, value in self.__dict__.iteritems()]
10389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10390 
 
10391 
  def __eq__(self, other):
10392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10393 
 
10394 
  def __ne__(self, other):
10395 
    return not (self == other)
10396 
 
483 rajveer 10397 
class changeOrderStatus_args:
94 ashish 10398 
  """
10399 
  Attributes:
483 rajveer 10400 
   - orderId
10401 
   - status
10402 
   - description
94 ashish 10403 
  """
10404 
 
10405 
  thrift_spec = (
10406 
    None, # 0
483 rajveer 10407 
    (1, TType.I64, 'orderId', None, None, ), # 1
10408 
    (2, TType.I32, 'status', None, None, ), # 2
10409 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10410 
  )
10411 
 
483 rajveer 10412 
  def __init__(self, orderId=None, status=None, description=None,):
10413 
    self.orderId = orderId
10414 
    self.status = status
10415 
    self.description = description
94 ashish 10416 
 
10417 
  def read(self, iprot):
10418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10420 
      return
10421 
    iprot.readStructBegin()
10422 
    while True:
10423 
      (fname, ftype, fid) = iprot.readFieldBegin()
10424 
      if ftype == TType.STOP:
10425 
        break
10426 
      if fid == 1:
10427 
        if ftype == TType.I64:
483 rajveer 10428 
          self.orderId = iprot.readI64();
94 ashish 10429 
        else:
10430 
          iprot.skip(ftype)
10431 
      elif fid == 2:
483 rajveer 10432 
        if ftype == TType.I32:
10433 
          self.status = iprot.readI32();
94 ashish 10434 
        else:
10435 
          iprot.skip(ftype)
483 rajveer 10436 
      elif fid == 3:
10437 
        if ftype == TType.STRING:
10438 
          self.description = iprot.readString();
10439 
        else:
10440 
          iprot.skip(ftype)
94 ashish 10441 
      else:
10442 
        iprot.skip(ftype)
10443 
      iprot.readFieldEnd()
10444 
    iprot.readStructEnd()
10445 
 
10446 
  def write(self, oprot):
10447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10449 
      return
483 rajveer 10450 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10451 
    if self.orderId is not None:
483 rajveer 10452 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10453 
      oprot.writeI64(self.orderId)
94 ashish 10454 
      oprot.writeFieldEnd()
3431 rajveer 10455 
    if self.status is not None:
483 rajveer 10456 
      oprot.writeFieldBegin('status', TType.I32, 2)
10457 
      oprot.writeI32(self.status)
94 ashish 10458 
      oprot.writeFieldEnd()
3431 rajveer 10459 
    if self.description is not None:
483 rajveer 10460 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10461 
      oprot.writeString(self.description)
10462 
      oprot.writeFieldEnd()
94 ashish 10463 
    oprot.writeFieldStop()
10464 
    oprot.writeStructEnd()
10465 
 
3431 rajveer 10466 
  def validate(self):
10467 
    return
10468 
 
10469 
 
94 ashish 10470 
  def __repr__(self):
10471 
    L = ['%s=%r' % (key, value)
10472 
      for key, value in self.__dict__.iteritems()]
10473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10474 
 
10475 
  def __eq__(self, other):
10476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10477 
 
10478 
  def __ne__(self, other):
10479 
    return not (self == other)
10480 
 
483 rajveer 10481 
class changeOrderStatus_result:
94 ashish 10482 
  """
10483 
  Attributes:
10484 
   - success
10485 
   - ex
10486 
  """
10487 
 
10488 
  thrift_spec = (
10489 
    (0, TType.BOOL, 'success', None, None, ), # 0
10490 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10491 
  )
10492 
 
10493 
  def __init__(self, success=None, ex=None,):
10494 
    self.success = success
10495 
    self.ex = ex
10496 
 
10497 
  def read(self, iprot):
10498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10500 
      return
10501 
    iprot.readStructBegin()
10502 
    while True:
10503 
      (fname, ftype, fid) = iprot.readFieldBegin()
10504 
      if ftype == TType.STOP:
10505 
        break
10506 
      if fid == 0:
10507 
        if ftype == TType.BOOL:
10508 
          self.success = iprot.readBool();
10509 
        else:
10510 
          iprot.skip(ftype)
10511 
      elif fid == 1:
10512 
        if ftype == TType.STRUCT:
10513 
          self.ex = TransactionServiceException()
10514 
          self.ex.read(iprot)
10515 
        else:
10516 
          iprot.skip(ftype)
10517 
      else:
10518 
        iprot.skip(ftype)
10519 
      iprot.readFieldEnd()
10520 
    iprot.readStructEnd()
10521 
 
10522 
  def write(self, oprot):
10523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10525 
      return
483 rajveer 10526 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10527 
    if self.success is not None:
94 ashish 10528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10529 
      oprot.writeBool(self.success)
10530 
      oprot.writeFieldEnd()
3431 rajveer 10531 
    if self.ex is not None:
94 ashish 10532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10533 
      self.ex.write(oprot)
10534 
      oprot.writeFieldEnd()
10535 
    oprot.writeFieldStop()
10536 
    oprot.writeStructEnd()
10537 
 
3431 rajveer 10538 
  def validate(self):
10539 
    return
10540 
 
10541 
 
94 ashish 10542 
  def __repr__(self):
10543 
    L = ['%s=%r' % (key, value)
10544 
      for key, value in self.__dict__.iteritems()]
10545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10546 
 
10547 
  def __eq__(self, other):
10548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10549 
 
10550 
  def __ne__(self, other):
10551 
    return not (self == other)
10552 
 
3064 chandransh 10553 
class getOrdersForTransaction_args:
494 rajveer 10554 
  """
10555 
  Attributes:
3064 chandransh 10556 
   - transactionId
10557 
   - customerId
494 rajveer 10558 
  """
10559 
 
10560 
  thrift_spec = (
10561 
    None, # 0
3064 chandransh 10562 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10563 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10564 
  )
10565 
 
3064 chandransh 10566 
  def __init__(self, transactionId=None, customerId=None,):
10567 
    self.transactionId = transactionId
10568 
    self.customerId = customerId
494 rajveer 10569 
 
10570 
  def read(self, iprot):
10571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10573 
      return
10574 
    iprot.readStructBegin()
10575 
    while True:
10576 
      (fname, ftype, fid) = iprot.readFieldBegin()
10577 
      if ftype == TType.STOP:
10578 
        break
10579 
      if fid == 1:
10580 
        if ftype == TType.I64:
3064 chandransh 10581 
          self.transactionId = iprot.readI64();
494 rajveer 10582 
        else:
10583 
          iprot.skip(ftype)
10584 
      elif fid == 2:
3064 chandransh 10585 
        if ftype == TType.I64:
10586 
          self.customerId = iprot.readI64();
494 rajveer 10587 
        else:
10588 
          iprot.skip(ftype)
10589 
      else:
10590 
        iprot.skip(ftype)
10591 
      iprot.readFieldEnd()
10592 
    iprot.readStructEnd()
10593 
 
10594 
  def write(self, oprot):
10595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10597 
      return
3064 chandransh 10598 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10599 
    if self.transactionId is not None:
3064 chandransh 10600 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10601 
      oprot.writeI64(self.transactionId)
494 rajveer 10602 
      oprot.writeFieldEnd()
3431 rajveer 10603 
    if self.customerId is not None:
3064 chandransh 10604 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10605 
      oprot.writeI64(self.customerId)
494 rajveer 10606 
      oprot.writeFieldEnd()
10607 
    oprot.writeFieldStop()
10608 
    oprot.writeStructEnd()
10609 
 
3431 rajveer 10610 
  def validate(self):
10611 
    return
10612 
 
10613 
 
494 rajveer 10614 
  def __repr__(self):
10615 
    L = ['%s=%r' % (key, value)
10616 
      for key, value in self.__dict__.iteritems()]
10617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10618 
 
10619 
  def __eq__(self, other):
10620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10621 
 
10622 
  def __ne__(self, other):
10623 
    return not (self == other)
10624 
 
3064 chandransh 10625 
class getOrdersForTransaction_result:
494 rajveer 10626 
  """
10627 
  Attributes:
10628 
   - success
10629 
   - ex
10630 
  """
10631 
 
10632 
  thrift_spec = (
3064 chandransh 10633 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10635 
  )
10636 
 
10637 
  def __init__(self, success=None, ex=None,):
10638 
    self.success = success
10639 
    self.ex = ex
10640 
 
10641 
  def read(self, iprot):
10642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10644 
      return
10645 
    iprot.readStructBegin()
10646 
    while True:
10647 
      (fname, ftype, fid) = iprot.readFieldBegin()
10648 
      if ftype == TType.STOP:
10649 
        break
10650 
      if fid == 0:
3064 chandransh 10651 
        if ftype == TType.LIST:
10652 
          self.success = []
6031 rajveer 10653 
          (_etype143, _size140) = iprot.readListBegin()
10654 
          for _i144 in xrange(_size140):
10655 
            _elem145 = Order()
10656 
            _elem145.read(iprot)
10657 
            self.success.append(_elem145)
3064 chandransh 10658 
          iprot.readListEnd()
494 rajveer 10659 
        else:
10660 
          iprot.skip(ftype)
10661 
      elif fid == 1:
10662 
        if ftype == TType.STRUCT:
10663 
          self.ex = TransactionServiceException()
10664 
          self.ex.read(iprot)
10665 
        else:
10666 
          iprot.skip(ftype)
10667 
      else:
10668 
        iprot.skip(ftype)
10669 
      iprot.readFieldEnd()
10670 
    iprot.readStructEnd()
10671 
 
10672 
  def write(self, oprot):
10673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10675 
      return
3064 chandransh 10676 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10677 
    if self.success is not None:
3064 chandransh 10678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10680 
      for iter146 in self.success:
10681 
        iter146.write(oprot)
3064 chandransh 10682 
      oprot.writeListEnd()
494 rajveer 10683 
      oprot.writeFieldEnd()
3431 rajveer 10684 
    if self.ex is not None:
494 rajveer 10685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10686 
      self.ex.write(oprot)
10687 
      oprot.writeFieldEnd()
10688 
    oprot.writeFieldStop()
10689 
    oprot.writeStructEnd()
10690 
 
3431 rajveer 10691 
  def validate(self):
10692 
    return
10693 
 
10694 
 
494 rajveer 10695 
  def __repr__(self):
10696 
    L = ['%s=%r' % (key, value)
10697 
      for key, value in self.__dict__.iteritems()]
10698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10699 
 
10700 
  def __eq__(self, other):
10701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10702 
 
10703 
  def __ne__(self, other):
10704 
    return not (self == other)
10705 
 
3064 chandransh 10706 
class getOrdersForCustomer_args:
1149 chandransh 10707 
  """
10708 
  Attributes:
3064 chandransh 10709 
   - customerId
10710 
   - from_date
10711 
   - to_date
10712 
   - statuses
1149 chandransh 10713 
  """
10714 
 
10715 
  thrift_spec = (
10716 
    None, # 0
3064 chandransh 10717 
    (1, TType.I64, 'customerId', None, None, ), # 1
10718 
    (2, TType.I64, 'from_date', None, None, ), # 2
10719 
    (3, TType.I64, 'to_date', None, None, ), # 3
10720 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10721 
  )
10722 
 
3064 chandransh 10723 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10724 
    self.customerId = customerId
10725 
    self.from_date = from_date
10726 
    self.to_date = to_date
10727 
    self.statuses = statuses
1149 chandransh 10728 
 
10729 
  def read(self, iprot):
10730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10732 
      return
10733 
    iprot.readStructBegin()
10734 
    while True:
10735 
      (fname, ftype, fid) = iprot.readFieldBegin()
10736 
      if ftype == TType.STOP:
10737 
        break
10738 
      if fid == 1:
10739 
        if ftype == TType.I64:
3064 chandransh 10740 
          self.customerId = iprot.readI64();
1149 chandransh 10741 
        else:
10742 
          iprot.skip(ftype)
10743 
      elif fid == 2:
10744 
        if ftype == TType.I64:
3064 chandransh 10745 
          self.from_date = iprot.readI64();
1149 chandransh 10746 
        else:
10747 
          iprot.skip(ftype)
2783 chandransh 10748 
      elif fid == 3:
10749 
        if ftype == TType.I64:
3064 chandransh 10750 
          self.to_date = iprot.readI64();
2783 chandransh 10751 
        else:
10752 
          iprot.skip(ftype)
10753 
      elif fid == 4:
3064 chandransh 10754 
        if ftype == TType.LIST:
10755 
          self.statuses = []
6031 rajveer 10756 
          (_etype150, _size147) = iprot.readListBegin()
10757 
          for _i151 in xrange(_size147):
10758 
            _elem152 = iprot.readI32();
10759 
            self.statuses.append(_elem152)
3064 chandransh 10760 
          iprot.readListEnd()
2783 chandransh 10761 
        else:
10762 
          iprot.skip(ftype)
1149 chandransh 10763 
      else:
10764 
        iprot.skip(ftype)
10765 
      iprot.readFieldEnd()
10766 
    iprot.readStructEnd()
10767 
 
10768 
  def write(self, oprot):
10769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10771 
      return
3064 chandransh 10772 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 10773 
    if self.customerId is not None:
3064 chandransh 10774 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
10775 
      oprot.writeI64(self.customerId)
1149 chandransh 10776 
      oprot.writeFieldEnd()
3431 rajveer 10777 
    if self.from_date is not None:
3064 chandransh 10778 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10779 
      oprot.writeI64(self.from_date)
1149 chandransh 10780 
      oprot.writeFieldEnd()
3431 rajveer 10781 
    if self.to_date is not None:
3064 chandransh 10782 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10783 
      oprot.writeI64(self.to_date)
2783 chandransh 10784 
      oprot.writeFieldEnd()
3431 rajveer 10785 
    if self.statuses is not None:
3064 chandransh 10786 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
10787 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6031 rajveer 10788 
      for iter153 in self.statuses:
10789 
        oprot.writeI32(iter153)
3064 chandransh 10790 
      oprot.writeListEnd()
2783 chandransh 10791 
      oprot.writeFieldEnd()
1149 chandransh 10792 
    oprot.writeFieldStop()
10793 
    oprot.writeStructEnd()
10794 
 
3431 rajveer 10795 
  def validate(self):
10796 
    return
10797 
 
10798 
 
1149 chandransh 10799 
  def __repr__(self):
10800 
    L = ['%s=%r' % (key, value)
10801 
      for key, value in self.__dict__.iteritems()]
10802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10803 
 
10804 
  def __eq__(self, other):
10805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10806 
 
10807 
  def __ne__(self, other):
10808 
    return not (self == other)
10809 
 
3064 chandransh 10810 
class getOrdersForCustomer_result:
1149 chandransh 10811 
  """
10812 
  Attributes:
10813 
   - success
10814 
   - ex
10815 
  """
10816 
 
10817 
  thrift_spec = (
3064 chandransh 10818 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 10819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10820 
  )
10821 
 
10822 
  def __init__(self, success=None, ex=None,):
10823 
    self.success = success
10824 
    self.ex = ex
10825 
 
10826 
  def read(self, iprot):
10827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10829 
      return
10830 
    iprot.readStructBegin()
10831 
    while True:
10832 
      (fname, ftype, fid) = iprot.readFieldBegin()
10833 
      if ftype == TType.STOP:
10834 
        break
10835 
      if fid == 0:
3064 chandransh 10836 
        if ftype == TType.LIST:
10837 
          self.success = []
6031 rajveer 10838 
          (_etype157, _size154) = iprot.readListBegin()
10839 
          for _i158 in xrange(_size154):
10840 
            _elem159 = Order()
10841 
            _elem159.read(iprot)
10842 
            self.success.append(_elem159)
3064 chandransh 10843 
          iprot.readListEnd()
1149 chandransh 10844 
        else:
10845 
          iprot.skip(ftype)
10846 
      elif fid == 1:
10847 
        if ftype == TType.STRUCT:
10848 
          self.ex = TransactionServiceException()
10849 
          self.ex.read(iprot)
10850 
        else:
10851 
          iprot.skip(ftype)
10852 
      else:
10853 
        iprot.skip(ftype)
10854 
      iprot.readFieldEnd()
10855 
    iprot.readStructEnd()
10856 
 
10857 
  def write(self, oprot):
10858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10860 
      return
3064 chandransh 10861 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 10862 
    if self.success is not None:
3064 chandransh 10863 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10864 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 10865 
      for iter160 in self.success:
10866 
        iter160.write(oprot)
3064 chandransh 10867 
      oprot.writeListEnd()
1149 chandransh 10868 
      oprot.writeFieldEnd()
3431 rajveer 10869 
    if self.ex is not None:
1149 chandransh 10870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10871 
      self.ex.write(oprot)
10872 
      oprot.writeFieldEnd()
10873 
    oprot.writeFieldStop()
10874 
    oprot.writeStructEnd()
10875 
 
3431 rajveer 10876 
  def validate(self):
10877 
    return
10878 
 
10879 
 
1149 chandransh 10880 
  def __repr__(self):
10881 
    L = ['%s=%r' % (key, value)
10882 
      for key, value in self.__dict__.iteritems()]
10883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10884 
 
10885 
  def __eq__(self, other):
10886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10887 
 
10888 
  def __ne__(self, other):
10889 
    return not (self == other)
10890 
 
3064 chandransh 10891 
class createOrder_args:
921 rajveer 10892 
  """
10893 
  Attributes:
3064 chandransh 10894 
   - order
921 rajveer 10895 
  """
10896 
 
10897 
  thrift_spec = (
10898 
    None, # 0
3064 chandransh 10899 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 10900 
  )
10901 
 
3064 chandransh 10902 
  def __init__(self, order=None,):
10903 
    self.order = order
921 rajveer 10904 
 
10905 
  def read(self, iprot):
10906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10908 
      return
10909 
    iprot.readStructBegin()
10910 
    while True:
10911 
      (fname, ftype, fid) = iprot.readFieldBegin()
10912 
      if ftype == TType.STOP:
10913 
        break
10914 
      if fid == 1:
3064 chandransh 10915 
        if ftype == TType.STRUCT:
10916 
          self.order = Order()
10917 
          self.order.read(iprot)
921 rajveer 10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
3064 chandransh 10929 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 10930 
    if self.order is not None:
3064 chandransh 10931 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
10932 
      self.order.write(oprot)
921 rajveer 10933 
      oprot.writeFieldEnd()
10934 
    oprot.writeFieldStop()
10935 
    oprot.writeStructEnd()
10936 
 
3431 rajveer 10937 
  def validate(self):
10938 
    return
10939 
 
10940 
 
921 rajveer 10941 
  def __repr__(self):
10942 
    L = ['%s=%r' % (key, value)
10943 
      for key, value in self.__dict__.iteritems()]
10944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10945 
 
10946 
  def __eq__(self, other):
10947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10948 
 
10949 
  def __ne__(self, other):
10950 
    return not (self == other)
10951 
 
3064 chandransh 10952 
class createOrder_result:
921 rajveer 10953 
  """
10954 
  Attributes:
10955 
   - success
10956 
   - ex
10957 
  """
10958 
 
10959 
  thrift_spec = (
3064 chandransh 10960 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 10961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10962 
  )
10963 
 
10964 
  def __init__(self, success=None, ex=None,):
10965 
    self.success = success
10966 
    self.ex = ex
10967 
 
10968 
  def read(self, iprot):
10969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10971 
      return
10972 
    iprot.readStructBegin()
10973 
    while True:
10974 
      (fname, ftype, fid) = iprot.readFieldBegin()
10975 
      if ftype == TType.STOP:
10976 
        break
10977 
      if fid == 0:
3064 chandransh 10978 
        if ftype == TType.I64:
10979 
          self.success = iprot.readI64();
921 rajveer 10980 
        else:
10981 
          iprot.skip(ftype)
10982 
      elif fid == 1:
10983 
        if ftype == TType.STRUCT:
10984 
          self.ex = TransactionServiceException()
10985 
          self.ex.read(iprot)
10986 
        else:
10987 
          iprot.skip(ftype)
10988 
      else:
10989 
        iprot.skip(ftype)
10990 
      iprot.readFieldEnd()
10991 
    iprot.readStructEnd()
10992 
 
10993 
  def write(self, oprot):
10994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10996 
      return
3064 chandransh 10997 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 10998 
    if self.success is not None:
3064 chandransh 10999 
      oprot.writeFieldBegin('success', TType.I64, 0)
11000 
      oprot.writeI64(self.success)
921 rajveer 11001 
      oprot.writeFieldEnd()
3431 rajveer 11002 
    if self.ex is not None:
921 rajveer 11003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11004 
      self.ex.write(oprot)
11005 
      oprot.writeFieldEnd()
11006 
    oprot.writeFieldStop()
11007 
    oprot.writeStructEnd()
11008 
 
3431 rajveer 11009 
  def validate(self):
11010 
    return
11011 
 
11012 
 
921 rajveer 11013 
  def __repr__(self):
11014 
    L = ['%s=%r' % (key, value)
11015 
      for key, value in self.__dict__.iteritems()]
11016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11017 
 
11018 
  def __eq__(self, other):
11019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11020 
 
11021 
  def __ne__(self, other):
11022 
    return not (self == other)
11023 
 
3064 chandransh 11024 
class getOrder_args:
921 rajveer 11025 
  """
11026 
  Attributes:
3064 chandransh 11027 
   - id
921 rajveer 11028 
  """
11029 
 
11030 
  thrift_spec = (
11031 
    None, # 0
3064 chandransh 11032 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11033 
  )
11034 
 
3064 chandransh 11035 
  def __init__(self, id=None,):
11036 
    self.id = id
921 rajveer 11037 
 
11038 
  def read(self, iprot):
11039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11041 
      return
11042 
    iprot.readStructBegin()
11043 
    while True:
11044 
      (fname, ftype, fid) = iprot.readFieldBegin()
11045 
      if ftype == TType.STOP:
11046 
        break
11047 
      if fid == 1:
11048 
        if ftype == TType.I64:
3064 chandransh 11049 
          self.id = iprot.readI64();
921 rajveer 11050 
        else:
11051 
          iprot.skip(ftype)
11052 
      else:
11053 
        iprot.skip(ftype)
11054 
      iprot.readFieldEnd()
11055 
    iprot.readStructEnd()
11056 
 
11057 
  def write(self, oprot):
11058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11060 
      return
3064 chandransh 11061 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11062 
    if self.id is not None:
3064 chandransh 11063 
      oprot.writeFieldBegin('id', TType.I64, 1)
11064 
      oprot.writeI64(self.id)
921 rajveer 11065 
      oprot.writeFieldEnd()
11066 
    oprot.writeFieldStop()
11067 
    oprot.writeStructEnd()
11068 
 
3431 rajveer 11069 
  def validate(self):
11070 
    return
11071 
 
11072 
 
921 rajveer 11073 
  def __repr__(self):
11074 
    L = ['%s=%r' % (key, value)
11075 
      for key, value in self.__dict__.iteritems()]
11076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11077 
 
11078 
  def __eq__(self, other):
11079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11080 
 
11081 
  def __ne__(self, other):
11082 
    return not (self == other)
11083 
 
3064 chandransh 11084 
class getOrder_result:
921 rajveer 11085 
  """
11086 
  Attributes:
11087 
   - success
11088 
   - ex
11089 
  """
11090 
 
11091 
  thrift_spec = (
3064 chandransh 11092 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11094 
  )
11095 
 
11096 
  def __init__(self, success=None, ex=None,):
11097 
    self.success = success
11098 
    self.ex = ex
11099 
 
11100 
  def read(self, iprot):
11101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11103 
      return
11104 
    iprot.readStructBegin()
11105 
    while True:
11106 
      (fname, ftype, fid) = iprot.readFieldBegin()
11107 
      if ftype == TType.STOP:
11108 
        break
11109 
      if fid == 0:
3064 chandransh 11110 
        if ftype == TType.STRUCT:
11111 
          self.success = Order()
11112 
          self.success.read(iprot)
921 rajveer 11113 
        else:
11114 
          iprot.skip(ftype)
11115 
      elif fid == 1:
11116 
        if ftype == TType.STRUCT:
11117 
          self.ex = TransactionServiceException()
11118 
          self.ex.read(iprot)
11119 
        else:
11120 
          iprot.skip(ftype)
11121 
      else:
11122 
        iprot.skip(ftype)
11123 
      iprot.readFieldEnd()
11124 
    iprot.readStructEnd()
11125 
 
11126 
  def write(self, oprot):
11127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11129 
      return
3064 chandransh 11130 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11131 
    if self.success is not None:
3064 chandransh 11132 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11133 
      self.success.write(oprot)
921 rajveer 11134 
      oprot.writeFieldEnd()
3431 rajveer 11135 
    if self.ex is not None:
921 rajveer 11136 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11137 
      self.ex.write(oprot)
11138 
      oprot.writeFieldEnd()
11139 
    oprot.writeFieldStop()
11140 
    oprot.writeStructEnd()
11141 
 
3431 rajveer 11142 
  def validate(self):
11143 
    return
11144 
 
11145 
 
921 rajveer 11146 
  def __repr__(self):
11147 
    L = ['%s=%r' % (key, value)
11148 
      for key, value in self.__dict__.iteritems()]
11149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11150 
 
11151 
  def __eq__(self, other):
11152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11153 
 
11154 
  def __ne__(self, other):
11155 
    return not (self == other)
11156 
 
3064 chandransh 11157 
class getLineItemsForOrder_args:
94 ashish 11158 
  """
11159 
  Attributes:
3064 chandransh 11160 
   - orderId
94 ashish 11161 
  """
11162 
 
11163 
  thrift_spec = (
11164 
    None, # 0
3064 chandransh 11165 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11166 
  )
11167 
 
3064 chandransh 11168 
  def __init__(self, orderId=None,):
11169 
    self.orderId = orderId
94 ashish 11170 
 
11171 
  def read(self, iprot):
11172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11174 
      return
11175 
    iprot.readStructBegin()
11176 
    while True:
11177 
      (fname, ftype, fid) = iprot.readFieldBegin()
11178 
      if ftype == TType.STOP:
11179 
        break
11180 
      if fid == 1:
11181 
        if ftype == TType.I64:
3064 chandransh 11182 
          self.orderId = iprot.readI64();
94 ashish 11183 
        else:
11184 
          iprot.skip(ftype)
11185 
      else:
11186 
        iprot.skip(ftype)
11187 
      iprot.readFieldEnd()
11188 
    iprot.readStructEnd()
11189 
 
11190 
  def write(self, oprot):
11191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11193 
      return
3064 chandransh 11194 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11195 
    if self.orderId is not None:
3064 chandransh 11196 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11197 
      oprot.writeI64(self.orderId)
94 ashish 11198 
      oprot.writeFieldEnd()
11199 
    oprot.writeFieldStop()
11200 
    oprot.writeStructEnd()
11201 
 
3431 rajveer 11202 
  def validate(self):
11203 
    return
11204 
 
11205 
 
94 ashish 11206 
  def __repr__(self):
11207 
    L = ['%s=%r' % (key, value)
11208 
      for key, value in self.__dict__.iteritems()]
11209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11210 
 
11211 
  def __eq__(self, other):
11212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11213 
 
11214 
  def __ne__(self, other):
11215 
    return not (self == other)
11216 
 
3064 chandransh 11217 
class getLineItemsForOrder_result:
94 ashish 11218 
  """
11219 
  Attributes:
11220 
   - success
11221 
   - ex
11222 
  """
11223 
 
11224 
  thrift_spec = (
3064 chandransh 11225 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11226 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11227 
  )
11228 
 
11229 
  def __init__(self, success=None, ex=None,):
11230 
    self.success = success
11231 
    self.ex = ex
11232 
 
11233 
  def read(self, iprot):
11234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11236 
      return
11237 
    iprot.readStructBegin()
11238 
    while True:
11239 
      (fname, ftype, fid) = iprot.readFieldBegin()
11240 
      if ftype == TType.STOP:
11241 
        break
11242 
      if fid == 0:
483 rajveer 11243 
        if ftype == TType.LIST:
11244 
          self.success = []
6031 rajveer 11245 
          (_etype164, _size161) = iprot.readListBegin()
11246 
          for _i165 in xrange(_size161):
11247 
            _elem166 = LineItem()
11248 
            _elem166.read(iprot)
11249 
            self.success.append(_elem166)
483 rajveer 11250 
          iprot.readListEnd()
94 ashish 11251 
        else:
11252 
          iprot.skip(ftype)
11253 
      elif fid == 1:
11254 
        if ftype == TType.STRUCT:
11255 
          self.ex = TransactionServiceException()
11256 
          self.ex.read(iprot)
11257 
        else:
11258 
          iprot.skip(ftype)
11259 
      else:
11260 
        iprot.skip(ftype)
11261 
      iprot.readFieldEnd()
11262 
    iprot.readStructEnd()
11263 
 
11264 
  def write(self, oprot):
11265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11267 
      return
3064 chandransh 11268 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11269 
    if self.success is not None:
483 rajveer 11270 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11271 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11272 
      for iter167 in self.success:
11273 
        iter167.write(oprot)
483 rajveer 11274 
      oprot.writeListEnd()
94 ashish 11275 
      oprot.writeFieldEnd()
3431 rajveer 11276 
    if self.ex is not None:
94 ashish 11277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11278 
      self.ex.write(oprot)
11279 
      oprot.writeFieldEnd()
11280 
    oprot.writeFieldStop()
11281 
    oprot.writeStructEnd()
11282 
 
3431 rajveer 11283 
  def validate(self):
11284 
    return
11285 
 
11286 
 
94 ashish 11287 
  def __repr__(self):
11288 
    L = ['%s=%r' % (key, value)
11289 
      for key, value in self.__dict__.iteritems()]
11290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11291 
 
11292 
  def __eq__(self, other):
11293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11294 
 
11295 
  def __ne__(self, other):
11296 
    return not (self == other)
11297 
 
4999 phani.kuma 11298 
class getOrderList_args:
11299 
  """
11300 
  Attributes:
11301 
   - order_ids
11302 
  """
11303 
 
11304 
  thrift_spec = (
11305 
    None, # 0
11306 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11307 
  )
11308 
 
11309 
  def __init__(self, order_ids=None,):
11310 
    self.order_ids = order_ids
11311 
 
11312 
  def read(self, iprot):
11313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11315 
      return
11316 
    iprot.readStructBegin()
11317 
    while True:
11318 
      (fname, ftype, fid) = iprot.readFieldBegin()
11319 
      if ftype == TType.STOP:
11320 
        break
11321 
      if fid == 1:
11322 
        if ftype == TType.LIST:
11323 
          self.order_ids = []
6031 rajveer 11324 
          (_etype171, _size168) = iprot.readListBegin()
11325 
          for _i172 in xrange(_size168):
11326 
            _elem173 = iprot.readI64();
11327 
            self.order_ids.append(_elem173)
4999 phani.kuma 11328 
          iprot.readListEnd()
11329 
        else:
11330 
          iprot.skip(ftype)
11331 
      else:
11332 
        iprot.skip(ftype)
11333 
      iprot.readFieldEnd()
11334 
    iprot.readStructEnd()
11335 
 
11336 
  def write(self, oprot):
11337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11339 
      return
11340 
    oprot.writeStructBegin('getOrderList_args')
11341 
    if self.order_ids is not None:
11342 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11343 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11344 
      for iter174 in self.order_ids:
11345 
        oprot.writeI64(iter174)
4999 phani.kuma 11346 
      oprot.writeListEnd()
11347 
      oprot.writeFieldEnd()
11348 
    oprot.writeFieldStop()
11349 
    oprot.writeStructEnd()
11350 
 
11351 
  def validate(self):
11352 
    return
11353 
 
11354 
 
11355 
  def __repr__(self):
11356 
    L = ['%s=%r' % (key, value)
11357 
      for key, value in self.__dict__.iteritems()]
11358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11359 
 
11360 
  def __eq__(self, other):
11361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11362 
 
11363 
  def __ne__(self, other):
11364 
    return not (self == other)
11365 
 
11366 
class getOrderList_result:
11367 
  """
11368 
  Attributes:
11369 
   - success
11370 
  """
11371 
 
11372 
  thrift_spec = (
11373 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11374 
  )
11375 
 
11376 
  def __init__(self, success=None,):
11377 
    self.success = success
11378 
 
11379 
  def read(self, iprot):
11380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11382 
      return
11383 
    iprot.readStructBegin()
11384 
    while True:
11385 
      (fname, ftype, fid) = iprot.readFieldBegin()
11386 
      if ftype == TType.STOP:
11387 
        break
11388 
      if fid == 0:
11389 
        if ftype == TType.LIST:
11390 
          self.success = []
6031 rajveer 11391 
          (_etype178, _size175) = iprot.readListBegin()
11392 
          for _i179 in xrange(_size175):
11393 
            _elem180 = Order()
11394 
            _elem180.read(iprot)
11395 
            self.success.append(_elem180)
4999 phani.kuma 11396 
          iprot.readListEnd()
11397 
        else:
11398 
          iprot.skip(ftype)
11399 
      else:
11400 
        iprot.skip(ftype)
11401 
      iprot.readFieldEnd()
11402 
    iprot.readStructEnd()
11403 
 
11404 
  def write(self, oprot):
11405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11407 
      return
11408 
    oprot.writeStructBegin('getOrderList_result')
11409 
    if self.success is not None:
11410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11411 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11412 
      for iter181 in self.success:
11413 
        iter181.write(oprot)
4999 phani.kuma 11414 
      oprot.writeListEnd()
11415 
      oprot.writeFieldEnd()
11416 
    oprot.writeFieldStop()
11417 
    oprot.writeStructEnd()
11418 
 
11419 
  def validate(self):
11420 
    return
11421 
 
11422 
 
11423 
  def __repr__(self):
11424 
    L = ['%s=%r' % (key, value)
11425 
      for key, value in self.__dict__.iteritems()]
11426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11427 
 
11428 
  def __eq__(self, other):
11429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11430 
 
11431 
  def __ne__(self, other):
11432 
    return not (self == other)
11433 
 
5386 phani.kuma 11434 
class getOrderListForVendor_args:
11435 
  """
11436 
  Attributes:
11437 
   - order_ids
11438 
   - vendorId
11439 
  """
11440 
 
11441 
  thrift_spec = (
11442 
    None, # 0
11443 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11444 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11445 
  )
11446 
 
11447 
  def __init__(self, order_ids=None, vendorId=None,):
11448 
    self.order_ids = order_ids
11449 
    self.vendorId = vendorId
11450 
 
11451 
  def read(self, iprot):
11452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11454 
      return
11455 
    iprot.readStructBegin()
11456 
    while True:
11457 
      (fname, ftype, fid) = iprot.readFieldBegin()
11458 
      if ftype == TType.STOP:
11459 
        break
11460 
      if fid == 1:
11461 
        if ftype == TType.LIST:
11462 
          self.order_ids = []
6031 rajveer 11463 
          (_etype185, _size182) = iprot.readListBegin()
11464 
          for _i186 in xrange(_size182):
11465 
            _elem187 = iprot.readI64();
11466 
            self.order_ids.append(_elem187)
5386 phani.kuma 11467 
          iprot.readListEnd()
11468 
        else:
11469 
          iprot.skip(ftype)
11470 
      elif fid == 2:
11471 
        if ftype == TType.I64:
11472 
          self.vendorId = iprot.readI64();
11473 
        else:
11474 
          iprot.skip(ftype)
11475 
      else:
11476 
        iprot.skip(ftype)
11477 
      iprot.readFieldEnd()
11478 
    iprot.readStructEnd()
11479 
 
11480 
  def write(self, oprot):
11481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11483 
      return
11484 
    oprot.writeStructBegin('getOrderListForVendor_args')
11485 
    if self.order_ids is not None:
11486 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11487 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6031 rajveer 11488 
      for iter188 in self.order_ids:
11489 
        oprot.writeI64(iter188)
5386 phani.kuma 11490 
      oprot.writeListEnd()
11491 
      oprot.writeFieldEnd()
11492 
    if self.vendorId is not None:
11493 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11494 
      oprot.writeI64(self.vendorId)
11495 
      oprot.writeFieldEnd()
11496 
    oprot.writeFieldStop()
11497 
    oprot.writeStructEnd()
11498 
 
11499 
  def validate(self):
11500 
    return
11501 
 
11502 
 
11503 
  def __repr__(self):
11504 
    L = ['%s=%r' % (key, value)
11505 
      for key, value in self.__dict__.iteritems()]
11506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11507 
 
11508 
  def __eq__(self, other):
11509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11510 
 
11511 
  def __ne__(self, other):
11512 
    return not (self == other)
11513 
 
11514 
class getOrderListForVendor_result:
11515 
  """
11516 
  Attributes:
11517 
   - success
11518 
  """
11519 
 
11520 
  thrift_spec = (
11521 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11522 
  )
11523 
 
11524 
  def __init__(self, success=None,):
11525 
    self.success = success
11526 
 
11527 
  def read(self, iprot):
11528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11530 
      return
11531 
    iprot.readStructBegin()
11532 
    while True:
11533 
      (fname, ftype, fid) = iprot.readFieldBegin()
11534 
      if ftype == TType.STOP:
11535 
        break
11536 
      if fid == 0:
11537 
        if ftype == TType.LIST:
11538 
          self.success = []
6031 rajveer 11539 
          (_etype192, _size189) = iprot.readListBegin()
11540 
          for _i193 in xrange(_size189):
11541 
            _elem194 = Order()
11542 
            _elem194.read(iprot)
11543 
            self.success.append(_elem194)
5386 phani.kuma 11544 
          iprot.readListEnd()
11545 
        else:
11546 
          iprot.skip(ftype)
11547 
      else:
11548 
        iprot.skip(ftype)
11549 
      iprot.readFieldEnd()
11550 
    iprot.readStructEnd()
11551 
 
11552 
  def write(self, oprot):
11553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11555 
      return
11556 
    oprot.writeStructBegin('getOrderListForVendor_result')
11557 
    if self.success is not None:
11558 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11559 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11560 
      for iter195 in self.success:
11561 
        iter195.write(oprot)
5386 phani.kuma 11562 
      oprot.writeListEnd()
11563 
      oprot.writeFieldEnd()
11564 
    oprot.writeFieldStop()
11565 
    oprot.writeStructEnd()
11566 
 
11567 
  def validate(self):
11568 
    return
11569 
 
11570 
 
11571 
  def __repr__(self):
11572 
    L = ['%s=%r' % (key, value)
11573 
      for key, value in self.__dict__.iteritems()]
11574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11575 
 
11576 
  def __eq__(self, other):
11577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11578 
 
11579 
  def __ne__(self, other):
11580 
    return not (self == other)
11581 
 
3064 chandransh 11582 
class getOrderForCustomer_args:
94 ashish 11583 
  """
11584 
  Attributes:
3064 chandransh 11585 
   - orderId
483 rajveer 11586 
   - customerId
94 ashish 11587 
  """
11588 
 
11589 
  thrift_spec = (
11590 
    None, # 0
3064 chandransh 11591 
    (1, TType.I64, 'orderId', None, None, ), # 1
11592 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11593 
  )
11594 
 
3064 chandransh 11595 
  def __init__(self, orderId=None, customerId=None,):
11596 
    self.orderId = orderId
483 rajveer 11597 
    self.customerId = customerId
94 ashish 11598 
 
11599 
  def read(self, iprot):
11600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11602 
      return
11603 
    iprot.readStructBegin()
11604 
    while True:
11605 
      (fname, ftype, fid) = iprot.readFieldBegin()
11606 
      if ftype == TType.STOP:
11607 
        break
11608 
      if fid == 1:
11609 
        if ftype == TType.I64:
3064 chandransh 11610 
          self.orderId = iprot.readI64();
94 ashish 11611 
        else:
11612 
          iprot.skip(ftype)
11613 
      elif fid == 2:
11614 
        if ftype == TType.I64:
3064 chandransh 11615 
          self.customerId = iprot.readI64();
94 ashish 11616 
        else:
11617 
          iprot.skip(ftype)
11618 
      else:
11619 
        iprot.skip(ftype)
11620 
      iprot.readFieldEnd()
11621 
    iprot.readStructEnd()
11622 
 
11623 
  def write(self, oprot):
11624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11626 
      return
3064 chandransh 11627 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11628 
    if self.orderId is not None:
3064 chandransh 11629 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11630 
      oprot.writeI64(self.orderId)
11631 
      oprot.writeFieldEnd()
3431 rajveer 11632 
    if self.customerId is not None:
3064 chandransh 11633 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11634 
      oprot.writeI64(self.customerId)
94 ashish 11635 
      oprot.writeFieldEnd()
11636 
    oprot.writeFieldStop()
11637 
    oprot.writeStructEnd()
11638 
 
3431 rajveer 11639 
  def validate(self):
11640 
    return
11641 
 
11642 
 
94 ashish 11643 
  def __repr__(self):
11644 
    L = ['%s=%r' % (key, value)
11645 
      for key, value in self.__dict__.iteritems()]
11646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11647 
 
11648 
  def __eq__(self, other):
11649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11650 
 
11651 
  def __ne__(self, other):
11652 
    return not (self == other)
11653 
 
3064 chandransh 11654 
class getOrderForCustomer_result:
94 ashish 11655 
  """
11656 
  Attributes:
11657 
   - success
11658 
   - ex
11659 
  """
11660 
 
11661 
  thrift_spec = (
3064 chandransh 11662 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11663 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11664 
  )
11665 
 
11666 
  def __init__(self, success=None, ex=None,):
11667 
    self.success = success
11668 
    self.ex = ex
11669 
 
11670 
  def read(self, iprot):
11671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11673 
      return
11674 
    iprot.readStructBegin()
11675 
    while True:
11676 
      (fname, ftype, fid) = iprot.readFieldBegin()
11677 
      if ftype == TType.STOP:
11678 
        break
11679 
      if fid == 0:
3064 chandransh 11680 
        if ftype == TType.STRUCT:
11681 
          self.success = Order()
11682 
          self.success.read(iprot)
94 ashish 11683 
        else:
11684 
          iprot.skip(ftype)
11685 
      elif fid == 1:
11686 
        if ftype == TType.STRUCT:
11687 
          self.ex = TransactionServiceException()
11688 
          self.ex.read(iprot)
11689 
        else:
11690 
          iprot.skip(ftype)
11691 
      else:
11692 
        iprot.skip(ftype)
11693 
      iprot.readFieldEnd()
11694 
    iprot.readStructEnd()
11695 
 
11696 
  def write(self, oprot):
11697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11699 
      return
3064 chandransh 11700 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11701 
    if self.success is not None:
3064 chandransh 11702 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11703 
      self.success.write(oprot)
94 ashish 11704 
      oprot.writeFieldEnd()
3431 rajveer 11705 
    if self.ex is not None:
94 ashish 11706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11707 
      self.ex.write(oprot)
11708 
      oprot.writeFieldEnd()
11709 
    oprot.writeFieldStop()
11710 
    oprot.writeStructEnd()
11711 
 
3431 rajveer 11712 
  def validate(self):
11713 
    return
11714 
 
11715 
 
94 ashish 11716 
  def __repr__(self):
11717 
    L = ['%s=%r' % (key, value)
11718 
      for key, value in self.__dict__.iteritems()]
11719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11720 
 
11721 
  def __eq__(self, other):
11722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11723 
 
11724 
  def __ne__(self, other):
11725 
    return not (self == other)
11726 
 
3064 chandransh 11727 
class getAlerts_args:
94 ashish 11728 
  """
11729 
  Attributes:
4394 rajveer 11730 
   - type
4444 rajveer 11731 
   - warehouseId
4394 rajveer 11732 
   - status
11733 
   - timestamp
94 ashish 11734 
  """
11735 
 
11736 
  thrift_spec = (
11737 
    None, # 0
4394 rajveer 11738 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11739 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11740 
    (3, TType.I64, 'status', None, None, ), # 3
11741 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 11742 
  )
11743 
 
4444 rajveer 11744 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 11745 
    self.type = type
4444 rajveer 11746 
    self.warehouseId = warehouseId
4394 rajveer 11747 
    self.status = status
11748 
    self.timestamp = timestamp
94 ashish 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 == 1:
3064 chandransh 11760 
        if ftype == TType.I64:
4394 rajveer 11761 
          self.type = iprot.readI64();
94 ashish 11762 
        else:
11763 
          iprot.skip(ftype)
3064 chandransh 11764 
      elif fid == 2:
4394 rajveer 11765 
        if ftype == TType.I64:
4444 rajveer 11766 
          self.warehouseId = iprot.readI64();
3064 chandransh 11767 
        else:
11768 
          iprot.skip(ftype)
4394 rajveer 11769 
      elif fid == 3:
11770 
        if ftype == TType.I64:
4444 rajveer 11771 
          self.status = iprot.readI64();
11772 
        else:
11773 
          iprot.skip(ftype)
11774 
      elif fid == 4:
11775 
        if ftype == TType.I64:
4394 rajveer 11776 
          self.timestamp = iprot.readI64();
11777 
        else:
11778 
          iprot.skip(ftype)
94 ashish 11779 
      else:
11780 
        iprot.skip(ftype)
11781 
      iprot.readFieldEnd()
11782 
    iprot.readStructEnd()
11783 
 
11784 
  def write(self, oprot):
11785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11787 
      return
3064 chandransh 11788 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 11789 
    if self.type is not None:
11790 
      oprot.writeFieldBegin('type', TType.I64, 1)
11791 
      oprot.writeI64(self.type)
94 ashish 11792 
      oprot.writeFieldEnd()
4444 rajveer 11793 
    if self.warehouseId is not None:
11794 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11795 
      oprot.writeI64(self.warehouseId)
11796 
      oprot.writeFieldEnd()
4394 rajveer 11797 
    if self.status is not None:
4444 rajveer 11798 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 11799 
      oprot.writeI64(self.status)
3064 chandransh 11800 
      oprot.writeFieldEnd()
4394 rajveer 11801 
    if self.timestamp is not None:
4444 rajveer 11802 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 11803 
      oprot.writeI64(self.timestamp)
11804 
      oprot.writeFieldEnd()
94 ashish 11805 
    oprot.writeFieldStop()
11806 
    oprot.writeStructEnd()
11807 
 
3431 rajveer 11808 
  def validate(self):
11809 
    return
11810 
 
11811 
 
94 ashish 11812 
  def __repr__(self):
11813 
    L = ['%s=%r' % (key, value)
11814 
      for key, value in self.__dict__.iteritems()]
11815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11816 
 
11817 
  def __eq__(self, other):
11818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11819 
 
11820 
  def __ne__(self, other):
11821 
    return not (self == other)
11822 
 
3064 chandransh 11823 
class getAlerts_result:
94 ashish 11824 
  """
11825 
  Attributes:
11826 
   - success
11827 
  """
11828 
 
11829 
  thrift_spec = (
3064 chandransh 11830 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 11831 
  )
11832 
 
3064 chandransh 11833 
  def __init__(self, success=None,):
94 ashish 11834 
    self.success = success
11835 
 
11836 
  def read(self, iprot):
11837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11839 
      return
11840 
    iprot.readStructBegin()
11841 
    while True:
11842 
      (fname, ftype, fid) = iprot.readFieldBegin()
11843 
      if ftype == TType.STOP:
11844 
        break
11845 
      if fid == 0:
3064 chandransh 11846 
        if ftype == TType.LIST:
11847 
          self.success = []
6031 rajveer 11848 
          (_etype199, _size196) = iprot.readListBegin()
11849 
          for _i200 in xrange(_size196):
11850 
            _elem201 = Alert()
11851 
            _elem201.read(iprot)
11852 
            self.success.append(_elem201)
3064 chandransh 11853 
          iprot.readListEnd()
94 ashish 11854 
        else:
11855 
          iprot.skip(ftype)
11856 
      else:
11857 
        iprot.skip(ftype)
11858 
      iprot.readFieldEnd()
11859 
    iprot.readStructEnd()
11860 
 
11861 
  def write(self, oprot):
11862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11864 
      return
3064 chandransh 11865 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 11866 
    if self.success is not None:
3064 chandransh 11867 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11868 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 11869 
      for iter202 in self.success:
11870 
        iter202.write(oprot)
3064 chandransh 11871 
      oprot.writeListEnd()
94 ashish 11872 
      oprot.writeFieldEnd()
11873 
    oprot.writeFieldStop()
11874 
    oprot.writeStructEnd()
11875 
 
3431 rajveer 11876 
  def validate(self):
11877 
    return
11878 
 
11879 
 
94 ashish 11880 
  def __repr__(self):
11881 
    L = ['%s=%r' % (key, value)
11882 
      for key, value in self.__dict__.iteritems()]
11883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11884 
 
11885 
  def __eq__(self, other):
11886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11887 
 
11888 
  def __ne__(self, other):
11889 
    return not (self == other)
11890 
 
4394 rajveer 11891 
class addAlert_args:
94 ashish 11892 
  """
11893 
  Attributes:
3064 chandransh 11894 
   - type
4444 rajveer 11895 
   - warehouseId
4394 rajveer 11896 
   - description
94 ashish 11897 
  """
11898 
 
11899 
  thrift_spec = (
11900 
    None, # 0
4394 rajveer 11901 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11902 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
11903 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11904 
  )
11905 
 
4444 rajveer 11906 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 11907 
    self.type = type
4444 rajveer 11908 
    self.warehouseId = warehouseId
4394 rajveer 11909 
    self.description = description
94 ashish 11910 
 
11911 
  def read(self, iprot):
11912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11914 
      return
11915 
    iprot.readStructBegin()
11916 
    while True:
11917 
      (fname, ftype, fid) = iprot.readFieldBegin()
11918 
      if ftype == TType.STOP:
11919 
        break
11920 
      if fid == 1:
11921 
        if ftype == TType.I64:
4394 rajveer 11922 
          self.type = iprot.readI64();
94 ashish 11923 
        else:
11924 
          iprot.skip(ftype)
3064 chandransh 11925 
      elif fid == 2:
4444 rajveer 11926 
        if ftype == TType.I64:
11927 
          self.warehouseId = iprot.readI64();
11928 
        else:
11929 
          iprot.skip(ftype)
11930 
      elif fid == 3:
3064 chandransh 11931 
        if ftype == TType.STRING:
4394 rajveer 11932 
          self.description = iprot.readString();
3064 chandransh 11933 
        else:
11934 
          iprot.skip(ftype)
94 ashish 11935 
      else:
11936 
        iprot.skip(ftype)
11937 
      iprot.readFieldEnd()
11938 
    iprot.readStructEnd()
11939 
 
11940 
  def write(self, oprot):
11941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11943 
      return
4394 rajveer 11944 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 11945 
    if self.type is not None:
4394 rajveer 11946 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 11947 
      oprot.writeI64(self.type)
11948 
      oprot.writeFieldEnd()
4444 rajveer 11949 
    if self.warehouseId is not None:
11950 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
11951 
      oprot.writeI64(self.warehouseId)
11952 
      oprot.writeFieldEnd()
4394 rajveer 11953 
    if self.description is not None:
4444 rajveer 11954 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 11955 
      oprot.writeString(self.description)
3064 chandransh 11956 
      oprot.writeFieldEnd()
94 ashish 11957 
    oprot.writeFieldStop()
11958 
    oprot.writeStructEnd()
11959 
 
3431 rajveer 11960 
  def validate(self):
11961 
    return
11962 
 
11963 
 
94 ashish 11964 
  def __repr__(self):
11965 
    L = ['%s=%r' % (key, value)
11966 
      for key, value in self.__dict__.iteritems()]
11967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11968 
 
11969 
  def __eq__(self, other):
11970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11971 
 
11972 
  def __ne__(self, other):
11973 
    return not (self == other)
11974 
 
4394 rajveer 11975 
class addAlert_result:
3064 chandransh 11976 
 
11977 
  thrift_spec = (
11978 
  )
11979 
 
11980 
  def read(self, iprot):
11981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11983 
      return
11984 
    iprot.readStructBegin()
11985 
    while True:
11986 
      (fname, ftype, fid) = iprot.readFieldBegin()
11987 
      if ftype == TType.STOP:
11988 
        break
11989 
      else:
11990 
        iprot.skip(ftype)
11991 
      iprot.readFieldEnd()
11992 
    iprot.readStructEnd()
11993 
 
11994 
  def write(self, oprot):
11995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11997 
      return
4394 rajveer 11998 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 11999 
    oprot.writeFieldStop()
12000 
    oprot.writeStructEnd()
12001 
 
3431 rajveer 12002 
  def validate(self):
12003 
    return
12004 
 
12005 
 
3064 chandransh 12006 
  def __repr__(self):
12007 
    L = ['%s=%r' % (key, value)
12008 
      for key, value in self.__dict__.iteritems()]
12009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12010 
 
12011 
  def __eq__(self, other):
12012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12013 
 
12014 
  def __ne__(self, other):
12015 
    return not (self == other)
12016 
 
4444 rajveer 12017 
class markAlertsAsSeen_args:
12018 
  """
12019 
  Attributes:
12020 
   - warehouseId
12021 
  """
12022 
 
12023 
  thrift_spec = (
12024 
    None, # 0
12025 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12026 
  )
12027 
 
12028 
  def __init__(self, warehouseId=None,):
12029 
    self.warehouseId = warehouseId
12030 
 
12031 
  def read(self, iprot):
12032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12034 
      return
12035 
    iprot.readStructBegin()
12036 
    while True:
12037 
      (fname, ftype, fid) = iprot.readFieldBegin()
12038 
      if ftype == TType.STOP:
12039 
        break
12040 
      if fid == 1:
12041 
        if ftype == TType.I64:
12042 
          self.warehouseId = iprot.readI64();
12043 
        else:
12044 
          iprot.skip(ftype)
12045 
      else:
12046 
        iprot.skip(ftype)
12047 
      iprot.readFieldEnd()
12048 
    iprot.readStructEnd()
12049 
 
12050 
  def write(self, oprot):
12051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12053 
      return
12054 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12055 
    if self.warehouseId is not None:
12056 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12057 
      oprot.writeI64(self.warehouseId)
12058 
      oprot.writeFieldEnd()
12059 
    oprot.writeFieldStop()
12060 
    oprot.writeStructEnd()
12061 
 
12062 
  def validate(self):
12063 
    return
12064 
 
12065 
 
12066 
  def __repr__(self):
12067 
    L = ['%s=%r' % (key, value)
12068 
      for key, value in self.__dict__.iteritems()]
12069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12070 
 
12071 
  def __eq__(self, other):
12072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12073 
 
12074 
  def __ne__(self, other):
12075 
    return not (self == other)
12076 
 
12077 
class markAlertsAsSeen_result:
12078 
 
12079 
  thrift_spec = (
12080 
  )
12081 
 
12082 
  def read(self, iprot):
12083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12085 
      return
12086 
    iprot.readStructBegin()
12087 
    while True:
12088 
      (fname, ftype, fid) = iprot.readFieldBegin()
12089 
      if ftype == TType.STOP:
12090 
        break
12091 
      else:
12092 
        iprot.skip(ftype)
12093 
      iprot.readFieldEnd()
12094 
    iprot.readStructEnd()
12095 
 
12096 
  def write(self, oprot):
12097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12099 
      return
12100 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12101 
    oprot.writeFieldStop()
12102 
    oprot.writeStructEnd()
12103 
 
12104 
  def validate(self):
12105 
    return
12106 
 
12107 
 
12108 
  def __repr__(self):
12109 
    L = ['%s=%r' % (key, value)
12110 
      for key, value in self.__dict__.iteritems()]
12111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12112 
 
12113 
  def __eq__(self, other):
12114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12115 
 
12116 
  def __ne__(self, other):
12117 
    return not (self == other)
12118 
 
3064 chandransh 12119 
class getValidOrderCount_args:
12120 
 
12121 
  thrift_spec = (
12122 
  )
12123 
 
12124 
  def read(self, iprot):
12125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12127 
      return
12128 
    iprot.readStructBegin()
12129 
    while True:
12130 
      (fname, ftype, fid) = iprot.readFieldBegin()
12131 
      if ftype == TType.STOP:
12132 
        break
12133 
      else:
12134 
        iprot.skip(ftype)
12135 
      iprot.readFieldEnd()
12136 
    iprot.readStructEnd()
12137 
 
12138 
  def write(self, oprot):
12139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12141 
      return
12142 
    oprot.writeStructBegin('getValidOrderCount_args')
12143 
    oprot.writeFieldStop()
12144 
    oprot.writeStructEnd()
12145 
 
3431 rajveer 12146 
  def validate(self):
12147 
    return
12148 
 
12149 
 
3064 chandransh 12150 
  def __repr__(self):
12151 
    L = ['%s=%r' % (key, value)
12152 
      for key, value in self.__dict__.iteritems()]
12153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12154 
 
12155 
  def __eq__(self, other):
12156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12157 
 
12158 
  def __ne__(self, other):
12159 
    return not (self == other)
12160 
 
12161 
class getValidOrderCount_result:
94 ashish 12162 
  """
12163 
  Attributes:
12164 
   - success
12165 
  """
12166 
 
12167 
  thrift_spec = (
3064 chandransh 12168 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12169 
  )
12170 
 
3064 chandransh 12171 
  def __init__(self, success=None,):
94 ashish 12172 
    self.success = success
12173 
 
12174 
  def read(self, iprot):
12175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12177 
      return
12178 
    iprot.readStructBegin()
12179 
    while True:
12180 
      (fname, ftype, fid) = iprot.readFieldBegin()
12181 
      if ftype == TType.STOP:
12182 
        break
12183 
      if fid == 0:
3064 chandransh 12184 
        if ftype == TType.I64:
12185 
          self.success = iprot.readI64();
94 ashish 12186 
        else:
12187 
          iprot.skip(ftype)
12188 
      else:
12189 
        iprot.skip(ftype)
12190 
      iprot.readFieldEnd()
12191 
    iprot.readStructEnd()
12192 
 
12193 
  def write(self, oprot):
12194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12196 
      return
3064 chandransh 12197 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12198 
    if self.success is not None:
3064 chandransh 12199 
      oprot.writeFieldBegin('success', TType.I64, 0)
12200 
      oprot.writeI64(self.success)
94 ashish 12201 
      oprot.writeFieldEnd()
12202 
    oprot.writeFieldStop()
12203 
    oprot.writeStructEnd()
12204 
 
3431 rajveer 12205 
  def validate(self):
12206 
    return
12207 
 
12208 
 
94 ashish 12209 
  def __repr__(self):
12210 
    L = ['%s=%r' % (key, value)
12211 
      for key, value in self.__dict__.iteritems()]
12212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12213 
 
12214 
  def __eq__(self, other):
12215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12216 
 
12217 
  def __ne__(self, other):
12218 
    return not (self == other)
12219 
 
3064 chandransh 12220 
class getNoOfCustomersWithSuccessfulTransaction_args:
12221 
 
12222 
  thrift_spec = (
12223 
  )
12224 
 
12225 
  def read(self, iprot):
12226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12228 
      return
12229 
    iprot.readStructBegin()
12230 
    while True:
12231 
      (fname, ftype, fid) = iprot.readFieldBegin()
12232 
      if ftype == TType.STOP:
12233 
        break
12234 
      else:
12235 
        iprot.skip(ftype)
12236 
      iprot.readFieldEnd()
12237 
    iprot.readStructEnd()
12238 
 
12239 
  def write(self, oprot):
12240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12242 
      return
12243 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12244 
    oprot.writeFieldStop()
12245 
    oprot.writeStructEnd()
12246 
 
3431 rajveer 12247 
  def validate(self):
12248 
    return
12249 
 
12250 
 
3064 chandransh 12251 
  def __repr__(self):
12252 
    L = ['%s=%r' % (key, value)
12253 
      for key, value in self.__dict__.iteritems()]
12254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12255 
 
12256 
  def __eq__(self, other):
12257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12258 
 
12259 
  def __ne__(self, other):
12260 
    return not (self == other)
12261 
 
12262 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12263 
  """
12264 
  Attributes:
3064 chandransh 12265 
   - success
94 ashish 12266 
  """
12267 
 
12268 
  thrift_spec = (
3064 chandransh 12269 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12270 
  )
12271 
 
3064 chandransh 12272 
  def __init__(self, success=None,):
12273 
    self.success = success
94 ashish 12274 
 
12275 
  def read(self, iprot):
12276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12278 
      return
12279 
    iprot.readStructBegin()
12280 
    while True:
12281 
      (fname, ftype, fid) = iprot.readFieldBegin()
12282 
      if ftype == TType.STOP:
12283 
        break
3064 chandransh 12284 
      if fid == 0:
94 ashish 12285 
        if ftype == TType.I64:
3064 chandransh 12286 
          self.success = iprot.readI64();
94 ashish 12287 
        else:
12288 
          iprot.skip(ftype)
12289 
      else:
12290 
        iprot.skip(ftype)
12291 
      iprot.readFieldEnd()
12292 
    iprot.readStructEnd()
12293 
 
12294 
  def write(self, oprot):
12295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12297 
      return
3064 chandransh 12298 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12299 
    if self.success is not None:
3064 chandransh 12300 
      oprot.writeFieldBegin('success', TType.I64, 0)
12301 
      oprot.writeI64(self.success)
94 ashish 12302 
      oprot.writeFieldEnd()
12303 
    oprot.writeFieldStop()
12304 
    oprot.writeStructEnd()
12305 
 
3431 rajveer 12306 
  def validate(self):
12307 
    return
12308 
 
12309 
 
94 ashish 12310 
  def __repr__(self):
12311 
    L = ['%s=%r' % (key, value)
12312 
      for key, value in self.__dict__.iteritems()]
12313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12314 
 
12315 
  def __eq__(self, other):
12316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12317 
 
12318 
  def __ne__(self, other):
12319 
    return not (self == other)
12320 
 
3064 chandransh 12321 
class getValidOrdersAmountRange_args:
12322 
 
12323 
  thrift_spec = (
12324 
  )
12325 
 
12326 
  def read(self, iprot):
12327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12329 
      return
12330 
    iprot.readStructBegin()
12331 
    while True:
12332 
      (fname, ftype, fid) = iprot.readFieldBegin()
12333 
      if ftype == TType.STOP:
12334 
        break
12335 
      else:
12336 
        iprot.skip(ftype)
12337 
      iprot.readFieldEnd()
12338 
    iprot.readStructEnd()
12339 
 
12340 
  def write(self, oprot):
12341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12343 
      return
12344 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12345 
    oprot.writeFieldStop()
12346 
    oprot.writeStructEnd()
12347 
 
3431 rajveer 12348 
  def validate(self):
12349 
    return
12350 
 
12351 
 
3064 chandransh 12352 
  def __repr__(self):
12353 
    L = ['%s=%r' % (key, value)
12354 
      for key, value in self.__dict__.iteritems()]
12355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12356 
 
12357 
  def __eq__(self, other):
12358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12359 
 
12360 
  def __ne__(self, other):
12361 
    return not (self == other)
12362 
 
12363 
class getValidOrdersAmountRange_result:
94 ashish 12364 
  """
12365 
  Attributes:
12366 
   - success
12367 
  """
12368 
 
12369 
  thrift_spec = (
3064 chandransh 12370 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12371 
  )
12372 
 
3064 chandransh 12373 
  def __init__(self, success=None,):
94 ashish 12374 
    self.success = success
12375 
 
12376 
  def read(self, iprot):
12377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12379 
      return
12380 
    iprot.readStructBegin()
12381 
    while True:
12382 
      (fname, ftype, fid) = iprot.readFieldBegin()
12383 
      if ftype == TType.STOP:
12384 
        break
12385 
      if fid == 0:
483 rajveer 12386 
        if ftype == TType.LIST:
12387 
          self.success = []
6031 rajveer 12388 
          (_etype206, _size203) = iprot.readListBegin()
12389 
          for _i207 in xrange(_size203):
12390 
            _elem208 = iprot.readDouble();
12391 
            self.success.append(_elem208)
483 rajveer 12392 
          iprot.readListEnd()
94 ashish 12393 
        else:
12394 
          iprot.skip(ftype)
12395 
      else:
12396 
        iprot.skip(ftype)
12397 
      iprot.readFieldEnd()
12398 
    iprot.readStructEnd()
12399 
 
12400 
  def write(self, oprot):
12401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12403 
      return
3064 chandransh 12404 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12405 
    if self.success is not None:
483 rajveer 12406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12407 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6031 rajveer 12408 
      for iter209 in self.success:
12409 
        oprot.writeDouble(iter209)
483 rajveer 12410 
      oprot.writeListEnd()
94 ashish 12411 
      oprot.writeFieldEnd()
12412 
    oprot.writeFieldStop()
12413 
    oprot.writeStructEnd()
12414 
 
3431 rajveer 12415 
  def validate(self):
12416 
    return
12417 
 
12418 
 
94 ashish 12419 
  def __repr__(self):
12420 
    L = ['%s=%r' % (key, value)
12421 
      for key, value in self.__dict__.iteritems()]
12422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12423 
 
12424 
  def __eq__(self, other):
12425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12426 
 
12427 
  def __ne__(self, other):
12428 
    return not (self == other)
12429 
 
3064 chandransh 12430 
class getValidOrders_args:
1528 ankur.sing 12431 
  """
12432 
  Attributes:
3064 chandransh 12433 
   - limit
5874 rajveer 12434 
   - onlyStore
1528 ankur.sing 12435 
  """
12436 
 
12437 
  thrift_spec = (
12438 
    None, # 0
3064 chandransh 12439 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12440 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12441 
  )
12442 
 
5874 rajveer 12443 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12444 
    self.limit = limit
5874 rajveer 12445 
    self.onlyStore = onlyStore
1528 ankur.sing 12446 
 
12447 
  def read(self, iprot):
12448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12450 
      return
12451 
    iprot.readStructBegin()
12452 
    while True:
12453 
      (fname, ftype, fid) = iprot.readFieldBegin()
12454 
      if ftype == TType.STOP:
12455 
        break
12456 
      if fid == 1:
12457 
        if ftype == TType.I64:
3064 chandransh 12458 
          self.limit = iprot.readI64();
1528 ankur.sing 12459 
        else:
12460 
          iprot.skip(ftype)
5874 rajveer 12461 
      elif fid == 2:
12462 
        if ftype == TType.BOOL:
12463 
          self.onlyStore = iprot.readBool();
12464 
        else:
12465 
          iprot.skip(ftype)
1528 ankur.sing 12466 
      else:
12467 
        iprot.skip(ftype)
12468 
      iprot.readFieldEnd()
12469 
    iprot.readStructEnd()
12470 
 
12471 
  def write(self, oprot):
12472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12474 
      return
3064 chandransh 12475 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12476 
    if self.limit is not None:
3064 chandransh 12477 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12478 
      oprot.writeI64(self.limit)
1528 ankur.sing 12479 
      oprot.writeFieldEnd()
5874 rajveer 12480 
    if self.onlyStore is not None:
12481 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12482 
      oprot.writeBool(self.onlyStore)
12483 
      oprot.writeFieldEnd()
1528 ankur.sing 12484 
    oprot.writeFieldStop()
12485 
    oprot.writeStructEnd()
12486 
 
3431 rajveer 12487 
  def validate(self):
12488 
    return
12489 
 
12490 
 
1528 ankur.sing 12491 
  def __repr__(self):
12492 
    L = ['%s=%r' % (key, value)
12493 
      for key, value in self.__dict__.iteritems()]
12494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12495 
 
12496 
  def __eq__(self, other):
12497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12498 
 
12499 
  def __ne__(self, other):
12500 
    return not (self == other)
12501 
 
3064 chandransh 12502 
class getValidOrders_result:
1528 ankur.sing 12503 
  """
12504 
  Attributes:
12505 
   - success
12506 
  """
12507 
 
12508 
  thrift_spec = (
3064 chandransh 12509 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12510 
  )
12511 
 
3064 chandransh 12512 
  def __init__(self, success=None,):
1528 ankur.sing 12513 
    self.success = success
12514 
 
12515 
  def read(self, iprot):
12516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12518 
      return
12519 
    iprot.readStructBegin()
12520 
    while True:
12521 
      (fname, ftype, fid) = iprot.readFieldBegin()
12522 
      if ftype == TType.STOP:
12523 
        break
12524 
      if fid == 0:
3064 chandransh 12525 
        if ftype == TType.LIST:
12526 
          self.success = []
6031 rajveer 12527 
          (_etype213, _size210) = iprot.readListBegin()
12528 
          for _i214 in xrange(_size210):
12529 
            _elem215 = Order()
12530 
            _elem215.read(iprot)
12531 
            self.success.append(_elem215)
3064 chandransh 12532 
          iprot.readListEnd()
1528 ankur.sing 12533 
        else:
12534 
          iprot.skip(ftype)
12535 
      else:
12536 
        iprot.skip(ftype)
12537 
      iprot.readFieldEnd()
12538 
    iprot.readStructEnd()
12539 
 
12540 
  def write(self, oprot):
12541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12543 
      return
3064 chandransh 12544 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12545 
    if self.success is not None:
3064 chandransh 12546 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12547 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12548 
      for iter216 in self.success:
12549 
        iter216.write(oprot)
3064 chandransh 12550 
      oprot.writeListEnd()
1528 ankur.sing 12551 
      oprot.writeFieldEnd()
12552 
    oprot.writeFieldStop()
12553 
    oprot.writeStructEnd()
12554 
 
3431 rajveer 12555 
  def validate(self):
12556 
    return
12557 
 
12558 
 
1528 ankur.sing 12559 
  def __repr__(self):
12560 
    L = ['%s=%r' % (key, value)
12561 
      for key, value in self.__dict__.iteritems()]
12562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12563 
 
12564 
  def __eq__(self, other):
12565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12566 
 
12567 
  def __ne__(self, other):
12568 
    return not (self == other)
12569 
 
1220 chandransh 12570 
class batchOrders_args:
12571 
  """
12572 
  Attributes:
12573 
   - warehouseId
12574 
  """
12575 
 
12576 
  thrift_spec = (
12577 
    None, # 0
12578 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12579 
  )
12580 
 
12581 
  def __init__(self, warehouseId=None,):
12582 
    self.warehouseId = warehouseId
12583 
 
12584 
  def read(self, iprot):
12585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12587 
      return
12588 
    iprot.readStructBegin()
12589 
    while True:
12590 
      (fname, ftype, fid) = iprot.readFieldBegin()
12591 
      if ftype == TType.STOP:
12592 
        break
12593 
      if fid == 1:
12594 
        if ftype == TType.I64:
12595 
          self.warehouseId = iprot.readI64();
12596 
        else:
12597 
          iprot.skip(ftype)
12598 
      else:
12599 
        iprot.skip(ftype)
12600 
      iprot.readFieldEnd()
12601 
    iprot.readStructEnd()
12602 
 
12603 
  def write(self, oprot):
12604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12606 
      return
12607 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12608 
    if self.warehouseId is not None:
1220 chandransh 12609 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12610 
      oprot.writeI64(self.warehouseId)
12611 
      oprot.writeFieldEnd()
12612 
    oprot.writeFieldStop()
12613 
    oprot.writeStructEnd()
12614 
 
3431 rajveer 12615 
  def validate(self):
12616 
    return
12617 
 
12618 
 
1220 chandransh 12619 
  def __repr__(self):
12620 
    L = ['%s=%r' % (key, value)
12621 
      for key, value in self.__dict__.iteritems()]
12622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12623 
 
12624 
  def __eq__(self, other):
12625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12626 
 
12627 
  def __ne__(self, other):
12628 
    return not (self == other)
12629 
 
12630 
class batchOrders_result:
12631 
  """
12632 
  Attributes:
12633 
   - success
12634 
   - ex
12635 
  """
12636 
 
12637 
  thrift_spec = (
12638 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12640 
  )
12641 
 
12642 
  def __init__(self, success=None, ex=None,):
12643 
    self.success = success
12644 
    self.ex = ex
12645 
 
12646 
  def read(self, iprot):
12647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12649 
      return
12650 
    iprot.readStructBegin()
12651 
    while True:
12652 
      (fname, ftype, fid) = iprot.readFieldBegin()
12653 
      if ftype == TType.STOP:
12654 
        break
12655 
      if fid == 0:
12656 
        if ftype == TType.LIST:
12657 
          self.success = []
6031 rajveer 12658 
          (_etype220, _size217) = iprot.readListBegin()
12659 
          for _i221 in xrange(_size217):
12660 
            _elem222 = Order()
12661 
            _elem222.read(iprot)
12662 
            self.success.append(_elem222)
1220 chandransh 12663 
          iprot.readListEnd()
12664 
        else:
12665 
          iprot.skip(ftype)
12666 
      elif fid == 1:
12667 
        if ftype == TType.STRUCT:
12668 
          self.ex = TransactionServiceException()
12669 
          self.ex.read(iprot)
12670 
        else:
12671 
          iprot.skip(ftype)
12672 
      else:
12673 
        iprot.skip(ftype)
12674 
      iprot.readFieldEnd()
12675 
    iprot.readStructEnd()
12676 
 
12677 
  def write(self, oprot):
12678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12680 
      return
12681 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12682 
    if self.success is not None:
1220 chandransh 12683 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12684 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 12685 
      for iter223 in self.success:
12686 
        iter223.write(oprot)
1220 chandransh 12687 
      oprot.writeListEnd()
12688 
      oprot.writeFieldEnd()
3431 rajveer 12689 
    if self.ex is not None:
1220 chandransh 12690 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12691 
      self.ex.write(oprot)
12692 
      oprot.writeFieldEnd()
12693 
    oprot.writeFieldStop()
12694 
    oprot.writeStructEnd()
12695 
 
3431 rajveer 12696 
  def validate(self):
12697 
    return
12698 
 
12699 
 
1220 chandransh 12700 
  def __repr__(self):
12701 
    L = ['%s=%r' % (key, value)
12702 
      for key, value in self.__dict__.iteritems()]
12703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12704 
 
12705 
  def __eq__(self, other):
12706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12707 
 
12708 
  def __ne__(self, other):
12709 
    return not (self == other)
12710 
 
1208 chandransh 12711 
class markOrderAsOutOfStock_args:
12712 
  """
12713 
  Attributes:
12714 
   - orderId
12715 
  """
12716 
 
12717 
  thrift_spec = (
12718 
    None, # 0
12719 
    (1, TType.I64, 'orderId', None, None, ), # 1
12720 
  )
12721 
 
12722 
  def __init__(self, orderId=None,):
12723 
    self.orderId = orderId
12724 
 
12725 
  def read(self, iprot):
12726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12728 
      return
12729 
    iprot.readStructBegin()
12730 
    while True:
12731 
      (fname, ftype, fid) = iprot.readFieldBegin()
12732 
      if ftype == TType.STOP:
12733 
        break
12734 
      if fid == 1:
12735 
        if ftype == TType.I64:
12736 
          self.orderId = iprot.readI64();
12737 
        else:
12738 
          iprot.skip(ftype)
12739 
      else:
12740 
        iprot.skip(ftype)
12741 
      iprot.readFieldEnd()
12742 
    iprot.readStructEnd()
12743 
 
12744 
  def write(self, oprot):
12745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12747 
      return
12748 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 12749 
    if self.orderId is not None:
1208 chandransh 12750 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12751 
      oprot.writeI64(self.orderId)
12752 
      oprot.writeFieldEnd()
12753 
    oprot.writeFieldStop()
12754 
    oprot.writeStructEnd()
12755 
 
3431 rajveer 12756 
  def validate(self):
12757 
    return
12758 
 
12759 
 
1208 chandransh 12760 
  def __repr__(self):
12761 
    L = ['%s=%r' % (key, value)
12762 
      for key, value in self.__dict__.iteritems()]
12763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12764 
 
12765 
  def __eq__(self, other):
12766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12767 
 
12768 
  def __ne__(self, other):
12769 
    return not (self == other)
12770 
 
12771 
class markOrderAsOutOfStock_result:
12772 
  """
12773 
  Attributes:
12774 
   - success
12775 
   - ex
12776 
  """
12777 
 
12778 
  thrift_spec = (
12779 
    (0, TType.BOOL, 'success', None, None, ), # 0
12780 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12781 
  )
12782 
 
12783 
  def __init__(self, success=None, ex=None,):
12784 
    self.success = success
12785 
    self.ex = ex
12786 
 
12787 
  def read(self, iprot):
12788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12790 
      return
12791 
    iprot.readStructBegin()
12792 
    while True:
12793 
      (fname, ftype, fid) = iprot.readFieldBegin()
12794 
      if ftype == TType.STOP:
12795 
        break
12796 
      if fid == 0:
12797 
        if ftype == TType.BOOL:
12798 
          self.success = iprot.readBool();
12799 
        else:
12800 
          iprot.skip(ftype)
12801 
      elif fid == 1:
12802 
        if ftype == TType.STRUCT:
12803 
          self.ex = TransactionServiceException()
12804 
          self.ex.read(iprot)
12805 
        else:
12806 
          iprot.skip(ftype)
12807 
      else:
12808 
        iprot.skip(ftype)
12809 
      iprot.readFieldEnd()
12810 
    iprot.readStructEnd()
12811 
 
12812 
  def write(self, oprot):
12813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12815 
      return
12816 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 12817 
    if self.success is not None:
1208 chandransh 12818 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12819 
      oprot.writeBool(self.success)
12820 
      oprot.writeFieldEnd()
3431 rajveer 12821 
    if self.ex is not None:
1208 chandransh 12822 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12823 
      self.ex.write(oprot)
12824 
      oprot.writeFieldEnd()
12825 
    oprot.writeFieldStop()
12826 
    oprot.writeStructEnd()
12827 
 
3431 rajveer 12828 
  def validate(self):
12829 
    return
12830 
 
12831 
 
1208 chandransh 12832 
  def __repr__(self):
12833 
    L = ['%s=%r' % (key, value)
12834 
      for key, value in self.__dict__.iteritems()]
12835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12836 
 
12837 
  def __eq__(self, other):
12838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12839 
 
12840 
  def __ne__(self, other):
12841 
    return not (self == other)
12842 
 
3064 chandransh 12843 
class verifyOrder_args:
759 chandransh 12844 
  """
12845 
  Attributes:
3064 chandransh 12846 
   - orderId
759 chandransh 12847 
  """
12848 
 
12849 
  thrift_spec = (
12850 
    None, # 0
3064 chandransh 12851 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 12852 
  )
12853 
 
3064 chandransh 12854 
  def __init__(self, orderId=None,):
12855 
    self.orderId = orderId
759 chandransh 12856 
 
12857 
  def read(self, iprot):
12858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12860 
      return
12861 
    iprot.readStructBegin()
12862 
    while True:
12863 
      (fname, ftype, fid) = iprot.readFieldBegin()
12864 
      if ftype == TType.STOP:
12865 
        break
12866 
      if fid == 1:
12867 
        if ftype == TType.I64:
3064 chandransh 12868 
          self.orderId = iprot.readI64();
759 chandransh 12869 
        else:
12870 
          iprot.skip(ftype)
12871 
      else:
12872 
        iprot.skip(ftype)
12873 
      iprot.readFieldEnd()
12874 
    iprot.readStructEnd()
12875 
 
12876 
  def write(self, oprot):
12877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12879 
      return
3064 chandransh 12880 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 12881 
    if self.orderId is not None:
3064 chandransh 12882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12883 
      oprot.writeI64(self.orderId)
759 chandransh 12884 
      oprot.writeFieldEnd()
12885 
    oprot.writeFieldStop()
12886 
    oprot.writeStructEnd()
12887 
 
3431 rajveer 12888 
  def validate(self):
12889 
    return
12890 
 
12891 
 
759 chandransh 12892 
  def __repr__(self):
12893 
    L = ['%s=%r' % (key, value)
12894 
      for key, value in self.__dict__.iteritems()]
12895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12896 
 
12897 
  def __eq__(self, other):
12898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12899 
 
12900 
  def __ne__(self, other):
12901 
    return not (self == other)
12902 
 
3064 chandransh 12903 
class verifyOrder_result:
759 chandransh 12904 
  """
12905 
  Attributes:
12906 
   - success
12907 
   - ex
12908 
  """
12909 
 
12910 
  thrift_spec = (
12911 
    (0, TType.BOOL, 'success', None, None, ), # 0
12912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12913 
  )
12914 
 
12915 
  def __init__(self, success=None, ex=None,):
12916 
    self.success = success
12917 
    self.ex = ex
12918 
 
12919 
  def read(self, iprot):
12920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12922 
      return
12923 
    iprot.readStructBegin()
12924 
    while True:
12925 
      (fname, ftype, fid) = iprot.readFieldBegin()
12926 
      if ftype == TType.STOP:
12927 
        break
12928 
      if fid == 0:
12929 
        if ftype == TType.BOOL:
12930 
          self.success = iprot.readBool();
12931 
        else:
12932 
          iprot.skip(ftype)
12933 
      elif fid == 1:
12934 
        if ftype == TType.STRUCT:
12935 
          self.ex = TransactionServiceException()
12936 
          self.ex.read(iprot)
12937 
        else:
12938 
          iprot.skip(ftype)
12939 
      else:
12940 
        iprot.skip(ftype)
12941 
      iprot.readFieldEnd()
12942 
    iprot.readStructEnd()
12943 
 
12944 
  def write(self, oprot):
12945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12947 
      return
3064 chandransh 12948 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 12949 
    if self.success is not None:
759 chandransh 12950 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12951 
      oprot.writeBool(self.success)
12952 
      oprot.writeFieldEnd()
3431 rajveer 12953 
    if self.ex is not None:
759 chandransh 12954 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12955 
      self.ex.write(oprot)
12956 
      oprot.writeFieldEnd()
12957 
    oprot.writeFieldStop()
12958 
    oprot.writeStructEnd()
12959 
 
3431 rajveer 12960 
  def validate(self):
12961 
    return
12962 
 
12963 
 
759 chandransh 12964 
  def __repr__(self):
12965 
    L = ['%s=%r' % (key, value)
12966 
      for key, value in self.__dict__.iteritems()]
12967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12968 
 
12969 
  def __eq__(self, other):
12970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12971 
 
12972 
  def __ne__(self, other):
12973 
    return not (self == other)
12974 
 
3064 chandransh 12975 
class acceptOrder_args:
1113 chandransh 12976 
  """
12977 
  Attributes:
3064 chandransh 12978 
   - orderId
1113 chandransh 12979 
  """
12980 
 
12981 
  thrift_spec = (
12982 
    None, # 0
3064 chandransh 12983 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 12984 
  )
12985 
 
3064 chandransh 12986 
  def __init__(self, orderId=None,):
12987 
    self.orderId = orderId
1113 chandransh 12988 
 
12989 
  def read(self, iprot):
12990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12992 
      return
12993 
    iprot.readStructBegin()
12994 
    while True:
12995 
      (fname, ftype, fid) = iprot.readFieldBegin()
12996 
      if ftype == TType.STOP:
12997 
        break
12998 
      if fid == 1:
12999 
        if ftype == TType.I64:
3064 chandransh 13000 
          self.orderId = iprot.readI64();
1113 chandransh 13001 
        else:
13002 
          iprot.skip(ftype)
13003 
      else:
13004 
        iprot.skip(ftype)
13005 
      iprot.readFieldEnd()
13006 
    iprot.readStructEnd()
13007 
 
13008 
  def write(self, oprot):
13009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13011 
      return
3064 chandransh 13012 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13013 
    if self.orderId is not None:
3064 chandransh 13014 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13015 
      oprot.writeI64(self.orderId)
1113 chandransh 13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
3431 rajveer 13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
1113 chandransh 13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
3064 chandransh 13035 
class acceptOrder_result:
1113 chandransh 13036 
  """
13037 
  Attributes:
13038 
   - success
13039 
   - ex
13040 
  """
13041 
 
13042 
  thrift_spec = (
3064 chandransh 13043 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13045 
  )
13046 
 
13047 
  def __init__(self, success=None, ex=None,):
13048 
    self.success = success
13049 
    self.ex = ex
13050 
 
13051 
  def read(self, iprot):
13052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13054 
      return
13055 
    iprot.readStructBegin()
13056 
    while True:
13057 
      (fname, ftype, fid) = iprot.readFieldBegin()
13058 
      if ftype == TType.STOP:
13059 
        break
13060 
      if fid == 0:
3064 chandransh 13061 
        if ftype == TType.BOOL:
13062 
          self.success = iprot.readBool();
1113 chandransh 13063 
        else:
13064 
          iprot.skip(ftype)
13065 
      elif fid == 1:
13066 
        if ftype == TType.STRUCT:
13067 
          self.ex = TransactionServiceException()
13068 
          self.ex.read(iprot)
13069 
        else:
13070 
          iprot.skip(ftype)
13071 
      else:
13072 
        iprot.skip(ftype)
13073 
      iprot.readFieldEnd()
13074 
    iprot.readStructEnd()
13075 
 
13076 
  def write(self, oprot):
13077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13079 
      return
3064 chandransh 13080 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13081 
    if self.success is not None:
3064 chandransh 13082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13083 
      oprot.writeBool(self.success)
1113 chandransh 13084 
      oprot.writeFieldEnd()
3431 rajveer 13085 
    if self.ex is not None:
1113 chandransh 13086 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13087 
      self.ex.write(oprot)
13088 
      oprot.writeFieldEnd()
13089 
    oprot.writeFieldStop()
13090 
    oprot.writeStructEnd()
13091 
 
3431 rajveer 13092 
  def validate(self):
13093 
    return
13094 
 
13095 
 
1113 chandransh 13096 
  def __repr__(self):
13097 
    L = ['%s=%r' % (key, value)
13098 
      for key, value in self.__dict__.iteritems()]
13099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13100 
 
13101 
  def __eq__(self, other):
13102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13103 
 
13104 
  def __ne__(self, other):
13105 
    return not (self == other)
13106 
 
3064 chandransh 13107 
class addBillingDetails_args:
1135 chandransh 13108 
  """
13109 
  Attributes:
3064 chandransh 13110 
   - orderId
13111 
   - invoice_number
4658 mandeep.dh 13112 
   - serialNumber
4283 anupam.sin 13113 
   - itemNumber
3064 chandransh 13114 
   - billed_by
4264 rajveer 13115 
   - jacketNumber
4283 anupam.sin 13116 
   - billingType
5110 mandeep.dh 13117 
   - fulfilmentWarehouseId
4763 rajveer 13118 
   - authorize
1135 chandransh 13119 
  """
13120 
 
13121 
  thrift_spec = (
13122 
    None, # 0
3064 chandransh 13123 
    (1, TType.I64, 'orderId', None, None, ), # 1
13124 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13125 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13126 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13127 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13128 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13129 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13130 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13131 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13132 
  )
13133 
 
5110 mandeep.dh 13134 
  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 13135 
    self.orderId = orderId
13136 
    self.invoice_number = invoice_number
4658 mandeep.dh 13137 
    self.serialNumber = serialNumber
4283 anupam.sin 13138 
    self.itemNumber = itemNumber
3064 chandransh 13139 
    self.billed_by = billed_by
4264 rajveer 13140 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13141 
    self.billingType = billingType
5110 mandeep.dh 13142 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13143 
    self.authorize = authorize
1135 chandransh 13144 
 
13145 
  def read(self, iprot):
13146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13148 
      return
13149 
    iprot.readStructBegin()
13150 
    while True:
13151 
      (fname, ftype, fid) = iprot.readFieldBegin()
13152 
      if ftype == TType.STOP:
13153 
        break
13154 
      if fid == 1:
13155 
        if ftype == TType.I64:
3064 chandransh 13156 
          self.orderId = iprot.readI64();
1135 chandransh 13157 
        else:
13158 
          iprot.skip(ftype)
13159 
      elif fid == 2:
3064 chandransh 13160 
        if ftype == TType.STRING:
13161 
          self.invoice_number = iprot.readString();
1135 chandransh 13162 
        else:
13163 
          iprot.skip(ftype)
3064 chandransh 13164 
      elif fid == 3:
5411 rajveer 13165 
        if ftype == TType.LIST:
13166 
          self.serialNumber = []
6031 rajveer 13167 
          (_etype227, _size224) = iprot.readListBegin()
13168 
          for _i228 in xrange(_size224):
13169 
            _elem229 = iprot.readString();
13170 
            self.serialNumber.append(_elem229)
5411 rajveer 13171 
          iprot.readListEnd()
3064 chandransh 13172 
        else:
13173 
          iprot.skip(ftype)
13174 
      elif fid == 4:
5411 rajveer 13175 
        if ftype == TType.LIST:
13176 
          self.itemNumber = []
6031 rajveer 13177 
          (_etype233, _size230) = iprot.readListBegin()
13178 
          for _i234 in xrange(_size230):
13179 
            _elem235 = iprot.readString();
13180 
            self.itemNumber.append(_elem235)
5411 rajveer 13181 
          iprot.readListEnd()
3064 chandransh 13182 
        else:
13183 
          iprot.skip(ftype)
13184 
      elif fid == 5:
13185 
        if ftype == TType.STRING:
4283 anupam.sin 13186 
          self.billed_by = iprot.readString();
3064 chandransh 13187 
        else:
13188 
          iprot.skip(ftype)
13189 
      elif fid == 6:
13190 
        if ftype == TType.I64:
4283 anupam.sin 13191 
          self.jacketNumber = iprot.readI64();
13192 
        else:
13193 
          iprot.skip(ftype)
13194 
      elif fid == 7:
13195 
        if ftype == TType.I64:
3064 chandransh 13196 
          self.billingType = iprot.readI64();
13197 
        else:
13198 
          iprot.skip(ftype)
4283 anupam.sin 13199 
      elif fid == 8:
13200 
        if ftype == TType.I64:
5110 mandeep.dh 13201 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13202 
        else:
13203 
          iprot.skip(ftype)
4763 rajveer 13204 
      elif fid == 9:
13205 
        if ftype == TType.BOOL:
13206 
          self.authorize = iprot.readBool();
13207 
        else:
13208 
          iprot.skip(ftype)
1246 chandransh 13209 
      else:
13210 
        iprot.skip(ftype)
13211 
      iprot.readFieldEnd()
13212 
    iprot.readStructEnd()
13213 
 
13214 
  def write(self, oprot):
13215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13217 
      return
4283 anupam.sin 13218 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13219 
    if self.orderId is not None:
3064 chandransh 13220 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13221 
      oprot.writeI64(self.orderId)
1246 chandransh 13222 
      oprot.writeFieldEnd()
4283 anupam.sin 13223 
    if self.invoice_number is not None:
13224 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13225 
      oprot.writeString(self.invoice_number)
1246 chandransh 13226 
      oprot.writeFieldEnd()
4658 mandeep.dh 13227 
    if self.serialNumber is not None:
5411 rajveer 13228 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13229 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6031 rajveer 13230 
      for iter236 in self.serialNumber:
13231 
        oprot.writeString(iter236)
5411 rajveer 13232 
      oprot.writeListEnd()
3064 chandransh 13233 
      oprot.writeFieldEnd()
3431 rajveer 13234 
    if self.itemNumber is not None:
5411 rajveer 13235 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13236 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6031 rajveer 13237 
      for iter237 in self.itemNumber:
13238 
        oprot.writeString(iter237)
5411 rajveer 13239 
      oprot.writeListEnd()
3064 chandransh 13240 
      oprot.writeFieldEnd()
4283 anupam.sin 13241 
    if self.billed_by is not None:
13242 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13243 
      oprot.writeString(self.billed_by)
3064 chandransh 13244 
      oprot.writeFieldEnd()
4283 anupam.sin 13245 
    if self.jacketNumber is not None:
13246 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13247 
      oprot.writeI64(self.jacketNumber)
13248 
      oprot.writeFieldEnd()
3431 rajveer 13249 
    if self.billingType is not None:
4283 anupam.sin 13250 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13251 
      oprot.writeI64(self.billingType)
13252 
      oprot.writeFieldEnd()
5110 mandeep.dh 13253 
    if self.fulfilmentWarehouseId is not None:
13254 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13255 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13256 
      oprot.writeFieldEnd()
4763 rajveer 13257 
    if self.authorize is not None:
13258 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13259 
      oprot.writeBool(self.authorize)
13260 
      oprot.writeFieldEnd()
1246 chandransh 13261 
    oprot.writeFieldStop()
13262 
    oprot.writeStructEnd()
13263 
 
3431 rajveer 13264 
  def validate(self):
13265 
    return
13266 
 
13267 
 
1246 chandransh 13268 
  def __repr__(self):
13269 
    L = ['%s=%r' % (key, value)
13270 
      for key, value in self.__dict__.iteritems()]
13271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13272 
 
13273 
  def __eq__(self, other):
13274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13275 
 
13276 
  def __ne__(self, other):
13277 
    return not (self == other)
13278 
 
4283 anupam.sin 13279 
class addBillingDetails_result:
1246 chandransh 13280 
  """
13281 
  Attributes:
3064 chandransh 13282 
   - success
1246 chandransh 13283 
   - ex
13284 
  """
13285 
 
13286 
  thrift_spec = (
3064 chandransh 13287 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13289 
  )
13290 
 
3064 chandransh 13291 
  def __init__(self, success=None, ex=None,):
13292 
    self.success = success
1246 chandransh 13293 
    self.ex = ex
13294 
 
13295 
  def read(self, iprot):
13296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13298 
      return
13299 
    iprot.readStructBegin()
13300 
    while True:
13301 
      (fname, ftype, fid) = iprot.readFieldBegin()
13302 
      if ftype == TType.STOP:
13303 
        break
3064 chandransh 13304 
      if fid == 0:
13305 
        if ftype == TType.BOOL:
13306 
          self.success = iprot.readBool();
13307 
        else:
13308 
          iprot.skip(ftype)
13309 
      elif fid == 1:
1246 chandransh 13310 
        if ftype == TType.STRUCT:
13311 
          self.ex = TransactionServiceException()
13312 
          self.ex.read(iprot)
13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      else:
13316 
        iprot.skip(ftype)
13317 
      iprot.readFieldEnd()
13318 
    iprot.readStructEnd()
13319 
 
13320 
  def write(self, oprot):
13321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13323 
      return
4283 anupam.sin 13324 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13325 
    if self.success is not None:
3064 chandransh 13326 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13327 
      oprot.writeBool(self.success)
13328 
      oprot.writeFieldEnd()
3431 rajveer 13329 
    if self.ex is not None:
1246 chandransh 13330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13331 
      self.ex.write(oprot)
13332 
      oprot.writeFieldEnd()
13333 
    oprot.writeFieldStop()
13334 
    oprot.writeStructEnd()
13335 
 
3431 rajveer 13336 
  def validate(self):
13337 
    return
13338 
 
13339 
 
1246 chandransh 13340 
  def __repr__(self):
13341 
    L = ['%s=%r' % (key, value)
13342 
      for key, value in self.__dict__.iteritems()]
13343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13344 
 
13345 
  def __eq__(self, other):
13346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13347 
 
13348 
  def __ne__(self, other):
13349 
    return not (self == other)
13350 
 
4579 rajveer 13351 
class addInvoiceNumber_args:
13352 
  """
13353 
  Attributes:
13354 
   - orderId
13355 
   - invoiceNumber
4763 rajveer 13356 
   - color
4579 rajveer 13357 
  """
13358 
 
13359 
  thrift_spec = (
13360 
    None, # 0
13361 
    (1, TType.I64, 'orderId', None, None, ), # 1
13362 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13363 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13364 
  )
13365 
 
4763 rajveer 13366 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13367 
    self.orderId = orderId
13368 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13369 
    self.color = color
4579 rajveer 13370 
 
13371 
  def read(self, iprot):
13372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13374 
      return
13375 
    iprot.readStructBegin()
13376 
    while True:
13377 
      (fname, ftype, fid) = iprot.readFieldBegin()
13378 
      if ftype == TType.STOP:
13379 
        break
13380 
      if fid == 1:
13381 
        if ftype == TType.I64:
13382 
          self.orderId = iprot.readI64();
13383 
        else:
13384 
          iprot.skip(ftype)
13385 
      elif fid == 2:
13386 
        if ftype == TType.STRING:
13387 
          self.invoiceNumber = iprot.readString();
13388 
        else:
13389 
          iprot.skip(ftype)
4763 rajveer 13390 
      elif fid == 3:
13391 
        if ftype == TType.STRING:
13392 
          self.color = iprot.readString();
13393 
        else:
13394 
          iprot.skip(ftype)
4579 rajveer 13395 
      else:
13396 
        iprot.skip(ftype)
13397 
      iprot.readFieldEnd()
13398 
    iprot.readStructEnd()
13399 
 
13400 
  def write(self, oprot):
13401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13403 
      return
13404 
    oprot.writeStructBegin('addInvoiceNumber_args')
13405 
    if self.orderId is not None:
13406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13407 
      oprot.writeI64(self.orderId)
13408 
      oprot.writeFieldEnd()
13409 
    if self.invoiceNumber is not None:
13410 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13411 
      oprot.writeString(self.invoiceNumber)
13412 
      oprot.writeFieldEnd()
4763 rajveer 13413 
    if self.color is not None:
13414 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13415 
      oprot.writeString(self.color)
13416 
      oprot.writeFieldEnd()
4579 rajveer 13417 
    oprot.writeFieldStop()
13418 
    oprot.writeStructEnd()
13419 
 
13420 
  def validate(self):
13421 
    return
13422 
 
13423 
 
13424 
  def __repr__(self):
13425 
    L = ['%s=%r' % (key, value)
13426 
      for key, value in self.__dict__.iteritems()]
13427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13428 
 
13429 
  def __eq__(self, other):
13430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13431 
 
13432 
  def __ne__(self, other):
13433 
    return not (self == other)
13434 
 
13435 
class addInvoiceNumber_result:
13436 
  """
13437 
  Attributes:
13438 
   - ex
13439 
  """
13440 
 
13441 
  thrift_spec = (
13442 
    None, # 0
13443 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13444 
  )
13445 
 
13446 
  def __init__(self, ex=None,):
13447 
    self.ex = ex
13448 
 
13449 
  def read(self, iprot):
13450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13452 
      return
13453 
    iprot.readStructBegin()
13454 
    while True:
13455 
      (fname, ftype, fid) = iprot.readFieldBegin()
13456 
      if ftype == TType.STOP:
13457 
        break
13458 
      if fid == 1:
13459 
        if ftype == TType.STRUCT:
13460 
          self.ex = TransactionServiceException()
13461 
          self.ex.read(iprot)
13462 
        else:
13463 
          iprot.skip(ftype)
13464 
      else:
13465 
        iprot.skip(ftype)
13466 
      iprot.readFieldEnd()
13467 
    iprot.readStructEnd()
13468 
 
13469 
  def write(self, oprot):
13470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13472 
      return
13473 
    oprot.writeStructBegin('addInvoiceNumber_result')
13474 
    if self.ex is not None:
13475 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13476 
      self.ex.write(oprot)
13477 
      oprot.writeFieldEnd()
13478 
    oprot.writeFieldStop()
13479 
    oprot.writeStructEnd()
13480 
 
13481 
  def validate(self):
13482 
    return
13483 
 
13484 
 
13485 
  def __repr__(self):
13486 
    L = ['%s=%r' % (key, value)
13487 
      for key, value in self.__dict__.iteritems()]
13488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13489 
 
13490 
  def __eq__(self, other):
13491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13492 
 
13493 
  def __ne__(self, other):
13494 
    return not (self == other)
13495 
 
4910 phani.kuma 13496 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13497 
  """
13498 
  Attributes:
3064 chandransh 13499 
   - warehouseId
1408 ankur.sing 13500 
   - providerId
3064 chandransh 13501 
   - cod
4910 phani.kuma 13502 
   - orderIds
1408 ankur.sing 13503 
  """
13504 
 
13505 
  thrift_spec = (
13506 
    None, # 0
3064 chandransh 13507 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13508 
    (2, TType.I64, 'providerId', None, None, ), # 2
13509 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13510 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13511 
  )
13512 
 
4910 phani.kuma 13513 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13514 
    self.warehouseId = warehouseId
1408 ankur.sing 13515 
    self.providerId = providerId
3064 chandransh 13516 
    self.cod = cod
4910 phani.kuma 13517 
    self.orderIds = orderIds
1408 ankur.sing 13518 
 
13519 
  def read(self, iprot):
13520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13522 
      return
13523 
    iprot.readStructBegin()
13524 
    while True:
13525 
      (fname, ftype, fid) = iprot.readFieldBegin()
13526 
      if ftype == TType.STOP:
13527 
        break
13528 
      if fid == 1:
13529 
        if ftype == TType.I64:
3064 chandransh 13530 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13531 
        else:
13532 
          iprot.skip(ftype)
13533 
      elif fid == 2:
13534 
        if ftype == TType.I64:
3064 chandransh 13535 
          self.providerId = iprot.readI64();
1408 ankur.sing 13536 
        else:
13537 
          iprot.skip(ftype)
3064 chandransh 13538 
      elif fid == 3:
13539 
        if ftype == TType.BOOL:
13540 
          self.cod = iprot.readBool();
13541 
        else:
13542 
          iprot.skip(ftype)
4910 phani.kuma 13543 
      elif fid == 4:
13544 
        if ftype == TType.LIST:
13545 
          self.orderIds = []
6031 rajveer 13546 
          (_etype241, _size238) = iprot.readListBegin()
13547 
          for _i242 in xrange(_size238):
13548 
            _elem243 = iprot.readI64();
13549 
            self.orderIds.append(_elem243)
4910 phani.kuma 13550 
          iprot.readListEnd()
13551 
        else:
13552 
          iprot.skip(ftype)
1408 ankur.sing 13553 
      else:
13554 
        iprot.skip(ftype)
13555 
      iprot.readFieldEnd()
13556 
    iprot.readStructEnd()
13557 
 
13558 
  def write(self, oprot):
13559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13561 
      return
4910 phani.kuma 13562 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13563 
    if self.warehouseId is not None:
3064 chandransh 13564 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13565 
      oprot.writeI64(self.warehouseId)
13566 
      oprot.writeFieldEnd()
3431 rajveer 13567 
    if self.providerId is not None:
3064 chandransh 13568 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13569 
      oprot.writeI64(self.providerId)
13570 
      oprot.writeFieldEnd()
3431 rajveer 13571 
    if self.cod is not None:
3064 chandransh 13572 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13573 
      oprot.writeBool(self.cod)
1408 ankur.sing 13574 
      oprot.writeFieldEnd()
4910 phani.kuma 13575 
    if self.orderIds is not None:
13576 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13577 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13578 
      for iter244 in self.orderIds:
13579 
        oprot.writeI64(iter244)
4910 phani.kuma 13580 
      oprot.writeListEnd()
13581 
      oprot.writeFieldEnd()
1408 ankur.sing 13582 
    oprot.writeFieldStop()
13583 
    oprot.writeStructEnd()
13584 
 
3431 rajveer 13585 
  def validate(self):
13586 
    return
13587 
 
13588 
 
1408 ankur.sing 13589 
  def __repr__(self):
13590 
    L = ['%s=%r' % (key, value)
13591 
      for key, value in self.__dict__.iteritems()]
13592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13593 
 
13594 
  def __eq__(self, other):
13595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13596 
 
13597 
  def __ne__(self, other):
13598 
    return not (self == other)
13599 
 
4910 phani.kuma 13600 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13601 
  """
13602 
  Attributes:
13603 
   - success
3064 chandransh 13604 
   - ex
1408 ankur.sing 13605 
  """
13606 
 
13607 
  thrift_spec = (
3064 chandransh 13608 
    (0, TType.BOOL, 'success', None, None, ), # 0
13609 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13610 
  )
13611 
 
3064 chandransh 13612 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13613 
    self.success = success
3064 chandransh 13614 
    self.ex = ex
1408 ankur.sing 13615 
 
13616 
  def read(self, iprot):
13617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13619 
      return
13620 
    iprot.readStructBegin()
13621 
    while True:
13622 
      (fname, ftype, fid) = iprot.readFieldBegin()
13623 
      if ftype == TType.STOP:
13624 
        break
13625 
      if fid == 0:
3064 chandransh 13626 
        if ftype == TType.BOOL:
13627 
          self.success = iprot.readBool();
1408 ankur.sing 13628 
        else:
13629 
          iprot.skip(ftype)
3064 chandransh 13630 
      elif fid == 1:
13631 
        if ftype == TType.STRUCT:
13632 
          self.ex = TransactionServiceException()
13633 
          self.ex.read(iprot)
13634 
        else:
13635 
          iprot.skip(ftype)
1408 ankur.sing 13636 
      else:
13637 
        iprot.skip(ftype)
13638 
      iprot.readFieldEnd()
13639 
    iprot.readStructEnd()
13640 
 
13641 
  def write(self, oprot):
13642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13644 
      return
4910 phani.kuma 13645 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13646 
    if self.success is not None:
3064 chandransh 13647 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13648 
      oprot.writeBool(self.success)
1408 ankur.sing 13649 
      oprot.writeFieldEnd()
3431 rajveer 13650 
    if self.ex is not None:
3064 chandransh 13651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13652 
      self.ex.write(oprot)
13653 
      oprot.writeFieldEnd()
1408 ankur.sing 13654 
    oprot.writeFieldStop()
13655 
    oprot.writeStructEnd()
13656 
 
3431 rajveer 13657 
  def validate(self):
13658 
    return
13659 
 
13660 
 
1408 ankur.sing 13661 
  def __repr__(self):
13662 
    L = ['%s=%r' % (key, value)
13663 
      for key, value in self.__dict__.iteritems()]
13664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13665 
 
13666 
  def __eq__(self, other):
13667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13668 
 
13669 
  def __ne__(self, other):
13670 
    return not (self == other)
13671 
 
5676 rajveer 13672 
class markOrdersAsReturnedFromStore_args:
13673 
  """
13674 
  Attributes:
13675 
   - providerId
13676 
   - orderIds
5713 rajveer 13677 
   - awbs
5676 rajveer 13678 
  """
13679 
 
13680 
  thrift_spec = (
13681 
    None, # 0
13682 
    (1, TType.I64, 'providerId', None, None, ), # 1
13683 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13684 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13685 
  )
13686 
 
5713 rajveer 13687 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13688 
    self.providerId = providerId
13689 
    self.orderIds = orderIds
5713 rajveer 13690 
    self.awbs = awbs
5676 rajveer 13691 
 
13692 
  def read(self, iprot):
13693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13695 
      return
13696 
    iprot.readStructBegin()
13697 
    while True:
13698 
      (fname, ftype, fid) = iprot.readFieldBegin()
13699 
      if ftype == TType.STOP:
13700 
        break
13701 
      if fid == 1:
13702 
        if ftype == TType.I64:
13703 
          self.providerId = iprot.readI64();
13704 
        else:
13705 
          iprot.skip(ftype)
13706 
      elif fid == 2:
13707 
        if ftype == TType.LIST:
13708 
          self.orderIds = []
6031 rajveer 13709 
          (_etype248, _size245) = iprot.readListBegin()
13710 
          for _i249 in xrange(_size245):
13711 
            _elem250 = iprot.readI64();
13712 
            self.orderIds.append(_elem250)
5676 rajveer 13713 
          iprot.readListEnd()
13714 
        else:
13715 
          iprot.skip(ftype)
5713 rajveer 13716 
      elif fid == 3:
13717 
        if ftype == TType.LIST:
13718 
          self.awbs = []
6031 rajveer 13719 
          (_etype254, _size251) = iprot.readListBegin()
13720 
          for _i255 in xrange(_size251):
13721 
            _elem256 = iprot.readString();
13722 
            self.awbs.append(_elem256)
5713 rajveer 13723 
          iprot.readListEnd()
13724 
        else:
13725 
          iprot.skip(ftype)
5676 rajveer 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
13735 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13736 
    if self.providerId is not None:
13737 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13738 
      oprot.writeI64(self.providerId)
13739 
      oprot.writeFieldEnd()
13740 
    if self.orderIds is not None:
13741 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
13742 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 13743 
      for iter257 in self.orderIds:
13744 
        oprot.writeI64(iter257)
5676 rajveer 13745 
      oprot.writeListEnd()
13746 
      oprot.writeFieldEnd()
5713 rajveer 13747 
    if self.awbs is not None:
13748 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
13749 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6031 rajveer 13750 
      for iter258 in self.awbs:
13751 
        oprot.writeString(iter258)
5713 rajveer 13752 
      oprot.writeListEnd()
13753 
      oprot.writeFieldEnd()
5676 rajveer 13754 
    oprot.writeFieldStop()
13755 
    oprot.writeStructEnd()
13756 
 
13757 
  def validate(self):
13758 
    return
13759 
 
13760 
 
13761 
  def __repr__(self):
13762 
    L = ['%s=%r' % (key, value)
13763 
      for key, value in self.__dict__.iteritems()]
13764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13765 
 
13766 
  def __eq__(self, other):
13767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13768 
 
13769 
  def __ne__(self, other):
13770 
    return not (self == other)
13771 
 
13772 
class markOrdersAsReturnedFromStore_result:
13773 
  """
13774 
  Attributes:
13775 
   - success
13776 
   - ex
13777 
  """
13778 
 
13779 
  thrift_spec = (
13780 
    (0, TType.BOOL, 'success', None, None, ), # 0
13781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13782 
  )
13783 
 
13784 
  def __init__(self, success=None, ex=None,):
13785 
    self.success = success
13786 
    self.ex = ex
13787 
 
13788 
  def read(self, iprot):
13789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13791 
      return
13792 
    iprot.readStructBegin()
13793 
    while True:
13794 
      (fname, ftype, fid) = iprot.readFieldBegin()
13795 
      if ftype == TType.STOP:
13796 
        break
13797 
      if fid == 0:
13798 
        if ftype == TType.BOOL:
13799 
          self.success = iprot.readBool();
13800 
        else:
13801 
          iprot.skip(ftype)
13802 
      elif fid == 1:
13803 
        if ftype == TType.STRUCT:
13804 
          self.ex = TransactionServiceException()
13805 
          self.ex.read(iprot)
13806 
        else:
13807 
          iprot.skip(ftype)
13808 
      else:
13809 
        iprot.skip(ftype)
13810 
      iprot.readFieldEnd()
13811 
    iprot.readStructEnd()
13812 
 
13813 
  def write(self, oprot):
13814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13816 
      return
13817 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
13818 
    if self.success is not None:
13819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13820 
      oprot.writeBool(self.success)
13821 
      oprot.writeFieldEnd()
13822 
    if self.ex is not None:
13823 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13824 
      self.ex.write(oprot)
13825 
      oprot.writeFieldEnd()
13826 
    oprot.writeFieldStop()
13827 
    oprot.writeStructEnd()
13828 
 
13829 
  def validate(self):
13830 
    return
13831 
 
13832 
 
13833 
  def __repr__(self):
13834 
    L = ['%s=%r' % (key, value)
13835 
      for key, value in self.__dict__.iteritems()]
13836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13837 
 
13838 
  def __eq__(self, other):
13839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13840 
 
13841 
  def __ne__(self, other):
13842 
    return not (self == other)
13843 
 
4910 phani.kuma 13844 
class markOrdersAsPickedUp_args:
4410 rajveer 13845 
  """
13846 
  Attributes:
13847 
   - providerId
4910 phani.kuma 13848 
   - pickupDetails
4410 rajveer 13849 
  """
13850 
 
13851 
  thrift_spec = (
13852 
    None, # 0
4910 phani.kuma 13853 
    (1, TType.I64, 'providerId', None, None, ), # 1
13854 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 13855 
  )
13856 
 
4910 phani.kuma 13857 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 13858 
    self.providerId = providerId
4910 phani.kuma 13859 
    self.pickupDetails = pickupDetails
4410 rajveer 13860 
 
13861 
  def read(self, iprot):
13862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13864 
      return
13865 
    iprot.readStructBegin()
13866 
    while True:
13867 
      (fname, ftype, fid) = iprot.readFieldBegin()
13868 
      if ftype == TType.STOP:
13869 
        break
13870 
      if fid == 1:
13871 
        if ftype == TType.I64:
4910 phani.kuma 13872 
          self.providerId = iprot.readI64();
4410 rajveer 13873 
        else:
13874 
          iprot.skip(ftype)
13875 
      elif fid == 2:
4910 phani.kuma 13876 
        if ftype == TType.MAP:
13877 
          self.pickupDetails = {}
6031 rajveer 13878 
          (_ktype260, _vtype261, _size259 ) = iprot.readMapBegin()
13879 
          for _i263 in xrange(_size259):
13880 
            _key264 = iprot.readString();
13881 
            _val265 = iprot.readString();
13882 
            self.pickupDetails[_key264] = _val265
4910 phani.kuma 13883 
          iprot.readMapEnd()
4410 rajveer 13884 
        else:
13885 
          iprot.skip(ftype)
13886 
      else:
13887 
        iprot.skip(ftype)
13888 
      iprot.readFieldEnd()
13889 
    iprot.readStructEnd()
13890 
 
13891 
  def write(self, oprot):
13892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13894 
      return
4910 phani.kuma 13895 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 13896 
    if self.providerId is not None:
4910 phani.kuma 13897 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 13898 
      oprot.writeI64(self.providerId)
13899 
      oprot.writeFieldEnd()
4910 phani.kuma 13900 
    if self.pickupDetails is not None:
13901 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
13902 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 13903 
      for kiter266,viter267 in self.pickupDetails.items():
13904 
        oprot.writeString(kiter266)
13905 
        oprot.writeString(viter267)
4910 phani.kuma 13906 
      oprot.writeMapEnd()
4410 rajveer 13907 
      oprot.writeFieldEnd()
13908 
    oprot.writeFieldStop()
13909 
    oprot.writeStructEnd()
13910 
 
13911 
  def validate(self):
13912 
    return
13913 
 
13914 
 
13915 
  def __repr__(self):
13916 
    L = ['%s=%r' % (key, value)
13917 
      for key, value in self.__dict__.iteritems()]
13918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13919 
 
13920 
  def __eq__(self, other):
13921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13922 
 
13923 
  def __ne__(self, other):
13924 
    return not (self == other)
13925 
 
4910 phani.kuma 13926 
class markOrdersAsPickedUp_result:
4410 rajveer 13927 
  """
13928 
  Attributes:
13929 
   - ex
13930 
  """
13931 
 
13932 
  thrift_spec = (
4910 phani.kuma 13933 
    None, # 0
4410 rajveer 13934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13935 
  )
13936 
 
4910 phani.kuma 13937 
  def __init__(self, ex=None,):
4410 rajveer 13938 
    self.ex = ex
13939 
 
13940 
  def read(self, iprot):
13941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13943 
      return
13944 
    iprot.readStructBegin()
13945 
    while True:
13946 
      (fname, ftype, fid) = iprot.readFieldBegin()
13947 
      if ftype == TType.STOP:
13948 
        break
4910 phani.kuma 13949 
      if fid == 1:
4410 rajveer 13950 
        if ftype == TType.STRUCT:
13951 
          self.ex = TransactionServiceException()
13952 
          self.ex.read(iprot)
13953 
        else:
13954 
          iprot.skip(ftype)
13955 
      else:
13956 
        iprot.skip(ftype)
13957 
      iprot.readFieldEnd()
13958 
    iprot.readStructEnd()
13959 
 
13960 
  def write(self, oprot):
13961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13963 
      return
4910 phani.kuma 13964 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 13965 
    if self.ex is not None:
13966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13967 
      self.ex.write(oprot)
13968 
      oprot.writeFieldEnd()
13969 
    oprot.writeFieldStop()
13970 
    oprot.writeStructEnd()
13971 
 
13972 
  def validate(self):
13973 
    return
13974 
 
13975 
 
13976 
  def __repr__(self):
13977 
    L = ['%s=%r' % (key, value)
13978 
      for key, value in self.__dict__.iteritems()]
13979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13980 
 
13981 
  def __eq__(self, other):
13982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13983 
 
13984 
  def __ne__(self, other):
13985 
    return not (self == other)
13986 
 
4910 phani.kuma 13987 
class getOrdersNotPickedUp_args:
304 ashish 13988 
  """
13989 
  Attributes:
3064 chandransh 13990 
   - providerId
304 ashish 13991 
  """
94 ashish 13992 
 
304 ashish 13993 
  thrift_spec = (
13994 
    None, # 0
3064 chandransh 13995 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 13996 
  )
13997 
 
4910 phani.kuma 13998 
  def __init__(self, providerId=None,):
3064 chandransh 13999 
    self.providerId = providerId
304 ashish 14000 
 
14001 
  def read(self, iprot):
14002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14004 
      return
14005 
    iprot.readStructBegin()
14006 
    while True:
14007 
      (fname, ftype, fid) = iprot.readFieldBegin()
14008 
      if ftype == TType.STOP:
14009 
        break
14010 
      if fid == 1:
14011 
        if ftype == TType.I64:
3064 chandransh 14012 
          self.providerId = iprot.readI64();
304 ashish 14013 
        else:
14014 
          iprot.skip(ftype)
14015 
      else:
14016 
        iprot.skip(ftype)
14017 
      iprot.readFieldEnd()
14018 
    iprot.readStructEnd()
14019 
 
14020 
  def write(self, oprot):
14021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14023 
      return
4910 phani.kuma 14024 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14025 
    if self.providerId is not None:
3064 chandransh 14026 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14027 
      oprot.writeI64(self.providerId)
304 ashish 14028 
      oprot.writeFieldEnd()
14029 
    oprot.writeFieldStop()
14030 
    oprot.writeStructEnd()
14031 
 
3431 rajveer 14032 
  def validate(self):
14033 
    return
14034 
 
14035 
 
304 ashish 14036 
  def __repr__(self):
14037 
    L = ['%s=%r' % (key, value)
14038 
      for key, value in self.__dict__.iteritems()]
14039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14040 
 
14041 
  def __eq__(self, other):
14042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14043 
 
14044 
  def __ne__(self, other):
14045 
    return not (self == other)
14046 
 
4910 phani.kuma 14047 
class getOrdersNotPickedUp_result:
304 ashish 14048 
  """
14049 
  Attributes:
14050 
   - success
14051 
  """
14052 
 
14053 
  thrift_spec = (
3064 chandransh 14054 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14055 
  )
14056 
 
4910 phani.kuma 14057 
  def __init__(self, success=None,):
304 ashish 14058 
    self.success = success
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 == 0:
14070 
        if ftype == TType.LIST:
14071 
          self.success = []
6031 rajveer 14072 
          (_etype271, _size268) = iprot.readListBegin()
14073 
          for _i272 in xrange(_size268):
14074 
            _elem273 = Order()
14075 
            _elem273.read(iprot)
14076 
            self.success.append(_elem273)
304 ashish 14077 
          iprot.readListEnd()
14078 
        else:
14079 
          iprot.skip(ftype)
14080 
      else:
14081 
        iprot.skip(ftype)
14082 
      iprot.readFieldEnd()
14083 
    iprot.readStructEnd()
14084 
 
14085 
  def write(self, oprot):
14086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14088 
      return
4910 phani.kuma 14089 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14090 
    if self.success is not None:
304 ashish 14091 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14092 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14093 
      for iter274 in self.success:
14094 
        iter274.write(oprot)
304 ashish 14095 
      oprot.writeListEnd()
14096 
      oprot.writeFieldEnd()
14097 
    oprot.writeFieldStop()
14098 
    oprot.writeStructEnd()
14099 
 
3431 rajveer 14100 
  def validate(self):
14101 
    return
14102 
 
14103 
 
304 ashish 14104 
  def __repr__(self):
14105 
    L = ['%s=%r' % (key, value)
14106 
      for key, value in self.__dict__.iteritems()]
14107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14108 
 
14109 
  def __eq__(self, other):
14110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14111 
 
14112 
  def __ne__(self, other):
14113 
    return not (self == other)
14114 
 
3064 chandransh 14115 
class markOrdersAsDelivered_args:
304 ashish 14116 
  """
14117 
  Attributes:
3064 chandransh 14118 
   - providerId
14119 
   - deliveredOrders
304 ashish 14120 
  """
14121 
 
14122 
  thrift_spec = (
14123 
    None, # 0
3064 chandransh 14124 
    (1, TType.I64, 'providerId', None, None, ), # 1
14125 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14126 
  )
14127 
 
3064 chandransh 14128 
  def __init__(self, providerId=None, deliveredOrders=None,):
14129 
    self.providerId = providerId
14130 
    self.deliveredOrders = deliveredOrders
304 ashish 14131 
 
14132 
  def read(self, iprot):
14133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14135 
      return
14136 
    iprot.readStructBegin()
14137 
    while True:
14138 
      (fname, ftype, fid) = iprot.readFieldBegin()
14139 
      if ftype == TType.STOP:
14140 
        break
14141 
      if fid == 1:
14142 
        if ftype == TType.I64:
3064 chandransh 14143 
          self.providerId = iprot.readI64();
304 ashish 14144 
        else:
14145 
          iprot.skip(ftype)
14146 
      elif fid == 2:
3064 chandransh 14147 
        if ftype == TType.MAP:
14148 
          self.deliveredOrders = {}
6031 rajveer 14149 
          (_ktype276, _vtype277, _size275 ) = iprot.readMapBegin()
14150 
          for _i279 in xrange(_size275):
14151 
            _key280 = iprot.readString();
14152 
            _val281 = iprot.readString();
14153 
            self.deliveredOrders[_key280] = _val281
3064 chandransh 14154 
          iprot.readMapEnd()
304 ashish 14155 
        else:
14156 
          iprot.skip(ftype)
14157 
      else:
14158 
        iprot.skip(ftype)
14159 
      iprot.readFieldEnd()
14160 
    iprot.readStructEnd()
14161 
 
14162 
  def write(self, oprot):
14163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14165 
      return
3064 chandransh 14166 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14167 
    if self.providerId is not None:
3064 chandransh 14168 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14169 
      oprot.writeI64(self.providerId)
304 ashish 14170 
      oprot.writeFieldEnd()
3431 rajveer 14171 
    if self.deliveredOrders is not None:
3064 chandransh 14172 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14173 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6031 rajveer 14174 
      for kiter282,viter283 in self.deliveredOrders.items():
14175 
        oprot.writeString(kiter282)
14176 
        oprot.writeString(viter283)
3064 chandransh 14177 
      oprot.writeMapEnd()
304 ashish 14178 
      oprot.writeFieldEnd()
14179 
    oprot.writeFieldStop()
14180 
    oprot.writeStructEnd()
14181 
 
3431 rajveer 14182 
  def validate(self):
14183 
    return
14184 
 
14185 
 
304 ashish 14186 
  def __repr__(self):
14187 
    L = ['%s=%r' % (key, value)
14188 
      for key, value in self.__dict__.iteritems()]
14189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14190 
 
14191 
  def __eq__(self, other):
14192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14193 
 
14194 
  def __ne__(self, other):
14195 
    return not (self == other)
14196 
 
3064 chandransh 14197 
class markOrdersAsDelivered_result:
14198 
  """
14199 
  Attributes:
14200 
   - ex
14201 
  """
304 ashish 14202 
 
14203 
  thrift_spec = (
3064 chandransh 14204 
    None, # 0
14205 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14206 
  )
14207 
 
3064 chandransh 14208 
  def __init__(self, ex=None,):
14209 
    self.ex = ex
304 ashish 14210 
 
1596 ankur.sing 14211 
  def read(self, iprot):
14212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14214 
      return
14215 
    iprot.readStructBegin()
14216 
    while True:
14217 
      (fname, ftype, fid) = iprot.readFieldBegin()
14218 
      if ftype == TType.STOP:
14219 
        break
3064 chandransh 14220 
      if fid == 1:
14221 
        if ftype == TType.STRUCT:
14222 
          self.ex = TransactionServiceException()
14223 
          self.ex.read(iprot)
14224 
        else:
14225 
          iprot.skip(ftype)
1596 ankur.sing 14226 
      else:
14227 
        iprot.skip(ftype)
14228 
      iprot.readFieldEnd()
14229 
    iprot.readStructEnd()
14230 
 
14231 
  def write(self, oprot):
14232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14234 
      return
3064 chandransh 14235 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14236 
    if self.ex is not None:
3064 chandransh 14237 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14238 
      self.ex.write(oprot)
14239 
      oprot.writeFieldEnd()
1596 ankur.sing 14240 
    oprot.writeFieldStop()
14241 
    oprot.writeStructEnd()
14242 
 
3431 rajveer 14243 
  def validate(self):
14244 
    return
14245 
 
14246 
 
1596 ankur.sing 14247 
  def __repr__(self):
14248 
    L = ['%s=%r' % (key, value)
14249 
      for key, value in self.__dict__.iteritems()]
14250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14251 
 
14252 
  def __eq__(self, other):
14253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14254 
 
14255 
  def __ne__(self, other):
14256 
    return not (self == other)
14257 
 
4910 phani.kuma 14258 
class markAsRTOrders_args:
1596 ankur.sing 14259 
  """
14260 
  Attributes:
3064 chandransh 14261 
   - providerId
14262 
   - returnedOrders
1596 ankur.sing 14263 
  """
14264 
 
14265 
  thrift_spec = (
3064 chandransh 14266 
    None, # 0
14267 
    (1, TType.I64, 'providerId', None, None, ), # 1
14268 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14269 
  )
14270 
 
3064 chandransh 14271 
  def __init__(self, providerId=None, returnedOrders=None,):
14272 
    self.providerId = providerId
14273 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14274 
 
14275 
  def read(self, iprot):
14276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14278 
      return
14279 
    iprot.readStructBegin()
14280 
    while True:
14281 
      (fname, ftype, fid) = iprot.readFieldBegin()
14282 
      if ftype == TType.STOP:
14283 
        break
3064 chandransh 14284 
      if fid == 1:
1596 ankur.sing 14285 
        if ftype == TType.I64:
3064 chandransh 14286 
          self.providerId = iprot.readI64();
1596 ankur.sing 14287 
        else:
14288 
          iprot.skip(ftype)
3064 chandransh 14289 
      elif fid == 2:
14290 
        if ftype == TType.MAP:
14291 
          self.returnedOrders = {}
6031 rajveer 14292 
          (_ktype285, _vtype286, _size284 ) = iprot.readMapBegin()
14293 
          for _i288 in xrange(_size284):
14294 
            _key289 = iprot.readString();
14295 
            _val290 = iprot.readString();
14296 
            self.returnedOrders[_key289] = _val290
3064 chandransh 14297 
          iprot.readMapEnd()
14298 
        else:
14299 
          iprot.skip(ftype)
1596 ankur.sing 14300 
      else:
14301 
        iprot.skip(ftype)
14302 
      iprot.readFieldEnd()
14303 
    iprot.readStructEnd()
14304 
 
14305 
  def write(self, oprot):
14306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14308 
      return
4910 phani.kuma 14309 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14310 
    if self.providerId is not None:
3064 chandransh 14311 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14312 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14313 
      oprot.writeFieldEnd()
3431 rajveer 14314 
    if self.returnedOrders is not None:
3064 chandransh 14315 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14316 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6031 rajveer 14317 
      for kiter291,viter292 in self.returnedOrders.items():
14318 
        oprot.writeString(kiter291)
14319 
        oprot.writeString(viter292)
3064 chandransh 14320 
      oprot.writeMapEnd()
14321 
      oprot.writeFieldEnd()
1596 ankur.sing 14322 
    oprot.writeFieldStop()
14323 
    oprot.writeStructEnd()
14324 
 
3431 rajveer 14325 
  def validate(self):
14326 
    return
14327 
 
14328 
 
1596 ankur.sing 14329 
  def __repr__(self):
14330 
    L = ['%s=%r' % (key, value)
14331 
      for key, value in self.__dict__.iteritems()]
14332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14333 
 
14334 
  def __eq__(self, other):
14335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14336 
 
14337 
  def __ne__(self, other):
14338 
    return not (self == other)
14339 
 
4910 phani.kuma 14340 
class markAsRTOrders_result:
3064 chandransh 14341 
  """
14342 
  Attributes:
14343 
   - ex
14344 
  """
1596 ankur.sing 14345 
 
1627 ankur.sing 14346 
  thrift_spec = (
3064 chandransh 14347 
    None, # 0
14348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14349 
  )
14350 
 
3064 chandransh 14351 
  def __init__(self, ex=None,):
14352 
    self.ex = ex
14353 
 
1627 ankur.sing 14354 
  def read(self, iprot):
14355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14357 
      return
14358 
    iprot.readStructBegin()
14359 
    while True:
14360 
      (fname, ftype, fid) = iprot.readFieldBegin()
14361 
      if ftype == TType.STOP:
14362 
        break
3064 chandransh 14363 
      if fid == 1:
14364 
        if ftype == TType.STRUCT:
14365 
          self.ex = TransactionServiceException()
14366 
          self.ex.read(iprot)
14367 
        else:
14368 
          iprot.skip(ftype)
1627 ankur.sing 14369 
      else:
14370 
        iprot.skip(ftype)
14371 
      iprot.readFieldEnd()
14372 
    iprot.readStructEnd()
14373 
 
14374 
  def write(self, oprot):
14375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14377 
      return
4910 phani.kuma 14378 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14379 
    if self.ex is not None:
3064 chandransh 14380 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14381 
      self.ex.write(oprot)
14382 
      oprot.writeFieldEnd()
1627 ankur.sing 14383 
    oprot.writeFieldStop()
14384 
    oprot.writeStructEnd()
14385 
 
3431 rajveer 14386 
  def validate(self):
14387 
    return
14388 
 
14389 
 
1627 ankur.sing 14390 
  def __repr__(self):
14391 
    L = ['%s=%r' % (key, value)
14392 
      for key, value in self.__dict__.iteritems()]
14393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14394 
 
14395 
  def __eq__(self, other):
14396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14397 
 
14398 
  def __ne__(self, other):
14399 
    return not (self == other)
14400 
 
4910 phani.kuma 14401 
class getRTOrders_args:
14402 
  """
14403 
  Attributes:
14404 
   - providerId
14405 
  """
14406 
 
14407 
  thrift_spec = (
14408 
    None, # 0
14409 
    (1, TType.I64, 'providerId', None, None, ), # 1
14410 
  )
14411 
 
14412 
  def __init__(self, providerId=None,):
14413 
    self.providerId = providerId
14414 
 
14415 
  def read(self, iprot):
14416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14418 
      return
14419 
    iprot.readStructBegin()
14420 
    while True:
14421 
      (fname, ftype, fid) = iprot.readFieldBegin()
14422 
      if ftype == TType.STOP:
14423 
        break
14424 
      if fid == 1:
14425 
        if ftype == TType.I64:
14426 
          self.providerId = iprot.readI64();
14427 
        else:
14428 
          iprot.skip(ftype)
14429 
      else:
14430 
        iprot.skip(ftype)
14431 
      iprot.readFieldEnd()
14432 
    iprot.readStructEnd()
14433 
 
14434 
  def write(self, oprot):
14435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14437 
      return
14438 
    oprot.writeStructBegin('getRTOrders_args')
14439 
    if self.providerId is not None:
14440 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14441 
      oprot.writeI64(self.providerId)
14442 
      oprot.writeFieldEnd()
14443 
    oprot.writeFieldStop()
14444 
    oprot.writeStructEnd()
14445 
 
14446 
  def validate(self):
14447 
    return
14448 
 
14449 
 
14450 
  def __repr__(self):
14451 
    L = ['%s=%r' % (key, value)
14452 
      for key, value in self.__dict__.iteritems()]
14453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14454 
 
14455 
  def __eq__(self, other):
14456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14457 
 
14458 
  def __ne__(self, other):
14459 
    return not (self == other)
14460 
 
14461 
class getRTOrders_result:
14462 
  """
14463 
  Attributes:
14464 
   - success
14465 
  """
14466 
 
14467 
  thrift_spec = (
14468 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14469 
  )
14470 
 
14471 
  def __init__(self, success=None,):
14472 
    self.success = success
14473 
 
14474 
  def read(self, iprot):
14475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14477 
      return
14478 
    iprot.readStructBegin()
14479 
    while True:
14480 
      (fname, ftype, fid) = iprot.readFieldBegin()
14481 
      if ftype == TType.STOP:
14482 
        break
14483 
      if fid == 0:
14484 
        if ftype == TType.LIST:
14485 
          self.success = []
6031 rajveer 14486 
          (_etype296, _size293) = iprot.readListBegin()
14487 
          for _i297 in xrange(_size293):
14488 
            _elem298 = Order()
14489 
            _elem298.read(iprot)
14490 
            self.success.append(_elem298)
4910 phani.kuma 14491 
          iprot.readListEnd()
14492 
        else:
14493 
          iprot.skip(ftype)
14494 
      else:
14495 
        iprot.skip(ftype)
14496 
      iprot.readFieldEnd()
14497 
    iprot.readStructEnd()
14498 
 
14499 
  def write(self, oprot):
14500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14502 
      return
14503 
    oprot.writeStructBegin('getRTOrders_result')
14504 
    if self.success is not None:
14505 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14506 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14507 
      for iter299 in self.success:
14508 
        iter299.write(oprot)
4910 phani.kuma 14509 
      oprot.writeListEnd()
14510 
      oprot.writeFieldEnd()
14511 
    oprot.writeFieldStop()
14512 
    oprot.writeStructEnd()
14513 
 
14514 
  def validate(self):
14515 
    return
14516 
 
14517 
 
14518 
  def __repr__(self):
14519 
    L = ['%s=%r' % (key, value)
14520 
      for key, value in self.__dict__.iteritems()]
14521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14522 
 
14523 
  def __eq__(self, other):
14524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14525 
 
14526 
  def __ne__(self, other):
14527 
    return not (self == other)
14528 
 
3064 chandransh 14529 
class updateNonDeliveryReason_args:
1627 ankur.sing 14530 
  """
14531 
  Attributes:
3064 chandransh 14532 
   - providerId
14533 
   - undeliveredOrders
1627 ankur.sing 14534 
  """
14535 
 
14536 
  thrift_spec = (
3064 chandransh 14537 
    None, # 0
14538 
    (1, TType.I64, 'providerId', None, None, ), # 1
14539 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14540 
  )
14541 
 
3064 chandransh 14542 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14543 
    self.providerId = providerId
14544 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14545 
 
14546 
  def read(self, iprot):
14547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14549 
      return
14550 
    iprot.readStructBegin()
14551 
    while True:
14552 
      (fname, ftype, fid) = iprot.readFieldBegin()
14553 
      if ftype == TType.STOP:
14554 
        break
3064 chandransh 14555 
      if fid == 1:
1627 ankur.sing 14556 
        if ftype == TType.I64:
3064 chandransh 14557 
          self.providerId = iprot.readI64();
1627 ankur.sing 14558 
        else:
14559 
          iprot.skip(ftype)
3064 chandransh 14560 
      elif fid == 2:
14561 
        if ftype == TType.MAP:
14562 
          self.undeliveredOrders = {}
6031 rajveer 14563 
          (_ktype301, _vtype302, _size300 ) = iprot.readMapBegin()
14564 
          for _i304 in xrange(_size300):
14565 
            _key305 = iprot.readString();
14566 
            _val306 = iprot.readString();
14567 
            self.undeliveredOrders[_key305] = _val306
3064 chandransh 14568 
          iprot.readMapEnd()
14569 
        else:
14570 
          iprot.skip(ftype)
1627 ankur.sing 14571 
      else:
14572 
        iprot.skip(ftype)
14573 
      iprot.readFieldEnd()
14574 
    iprot.readStructEnd()
14575 
 
14576 
  def write(self, oprot):
14577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14579 
      return
3064 chandransh 14580 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14581 
    if self.providerId is not None:
3064 chandransh 14582 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14583 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14584 
      oprot.writeFieldEnd()
3431 rajveer 14585 
    if self.undeliveredOrders is not None:
3064 chandransh 14586 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14587 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6031 rajveer 14588 
      for kiter307,viter308 in self.undeliveredOrders.items():
14589 
        oprot.writeString(kiter307)
14590 
        oprot.writeString(viter308)
3064 chandransh 14591 
      oprot.writeMapEnd()
14592 
      oprot.writeFieldEnd()
1627 ankur.sing 14593 
    oprot.writeFieldStop()
14594 
    oprot.writeStructEnd()
14595 
 
3431 rajveer 14596 
  def validate(self):
14597 
    return
14598 
 
14599 
 
1627 ankur.sing 14600 
  def __repr__(self):
14601 
    L = ['%s=%r' % (key, value)
14602 
      for key, value in self.__dict__.iteritems()]
14603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14604 
 
14605 
  def __eq__(self, other):
14606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14607 
 
14608 
  def __ne__(self, other):
14609 
    return not (self == other)
14610 
 
3064 chandransh 14611 
class updateNonDeliveryReason_result:
1627 ankur.sing 14612 
  """
14613 
  Attributes:
3064 chandransh 14614 
   - ex
1627 ankur.sing 14615 
  """
14616 
 
14617 
  thrift_spec = (
4910 phani.kuma 14618 
    None, # 0
3064 chandransh 14619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14620 
  )
14621 
 
4910 phani.kuma 14622 
  def __init__(self, ex=None,):
3064 chandransh 14623 
    self.ex = ex
1627 ankur.sing 14624 
 
14625 
  def read(self, iprot):
14626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14628 
      return
14629 
    iprot.readStructBegin()
14630 
    while True:
14631 
      (fname, ftype, fid) = iprot.readFieldBegin()
14632 
      if ftype == TType.STOP:
14633 
        break
4910 phani.kuma 14634 
      if fid == 1:
14635 
        if ftype == TType.STRUCT:
14636 
          self.ex = TransactionServiceException()
14637 
          self.ex.read(iprot)
14638 
        else:
14639 
          iprot.skip(ftype)
14640 
      else:
14641 
        iprot.skip(ftype)
14642 
      iprot.readFieldEnd()
14643 
    iprot.readStructEnd()
14644 
 
14645 
  def write(self, oprot):
14646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14648 
      return
14649 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14650 
    if self.ex is not None:
14651 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14652 
      self.ex.write(oprot)
14653 
      oprot.writeFieldEnd()
14654 
    oprot.writeFieldStop()
14655 
    oprot.writeStructEnd()
14656 
 
14657 
  def validate(self):
14658 
    return
14659 
 
14660 
 
14661 
  def __repr__(self):
14662 
    L = ['%s=%r' % (key, value)
14663 
      for key, value in self.__dict__.iteritems()]
14664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14665 
 
14666 
  def __eq__(self, other):
14667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14668 
 
14669 
  def __ne__(self, other):
14670 
    return not (self == other)
14671 
 
14672 
class getNonDeliveredOrdersbyCourier_args:
14673 
  """
14674 
  Attributes:
14675 
   - providerId
14676 
  """
14677 
 
14678 
  thrift_spec = (
14679 
    None, # 0
14680 
    (1, TType.I64, 'providerId', None, None, ), # 1
14681 
  )
14682 
 
14683 
  def __init__(self, providerId=None,):
14684 
    self.providerId = providerId
14685 
 
14686 
  def read(self, iprot):
14687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14689 
      return
14690 
    iprot.readStructBegin()
14691 
    while True:
14692 
      (fname, ftype, fid) = iprot.readFieldBegin()
14693 
      if ftype == TType.STOP:
14694 
        break
14695 
      if fid == 1:
14696 
        if ftype == TType.I64:
14697 
          self.providerId = iprot.readI64();
14698 
        else:
14699 
          iprot.skip(ftype)
14700 
      else:
14701 
        iprot.skip(ftype)
14702 
      iprot.readFieldEnd()
14703 
    iprot.readStructEnd()
14704 
 
14705 
  def write(self, oprot):
14706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14708 
      return
14709 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14710 
    if self.providerId is not None:
14711 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14712 
      oprot.writeI64(self.providerId)
14713 
      oprot.writeFieldEnd()
14714 
    oprot.writeFieldStop()
14715 
    oprot.writeStructEnd()
14716 
 
14717 
  def validate(self):
14718 
    return
14719 
 
14720 
 
14721 
  def __repr__(self):
14722 
    L = ['%s=%r' % (key, value)
14723 
      for key, value in self.__dict__.iteritems()]
14724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14725 
 
14726 
  def __eq__(self, other):
14727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14728 
 
14729 
  def __ne__(self, other):
14730 
    return not (self == other)
14731 
 
14732 
class getNonDeliveredOrdersbyCourier_result:
14733 
  """
14734 
  Attributes:
14735 
   - success
14736 
  """
14737 
 
14738 
  thrift_spec = (
14739 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14740 
  )
14741 
 
14742 
  def __init__(self, success=None,):
14743 
    self.success = success
14744 
 
14745 
  def read(self, iprot):
14746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14748 
      return
14749 
    iprot.readStructBegin()
14750 
    while True:
14751 
      (fname, ftype, fid) = iprot.readFieldBegin()
14752 
      if ftype == TType.STOP:
14753 
        break
4581 phani.kuma 14754 
      if fid == 0:
14755 
        if ftype == TType.LIST:
14756 
          self.success = []
6031 rajveer 14757 
          (_etype312, _size309) = iprot.readListBegin()
14758 
          for _i313 in xrange(_size309):
14759 
            _elem314 = Order()
14760 
            _elem314.read(iprot)
14761 
            self.success.append(_elem314)
4581 phani.kuma 14762 
          iprot.readListEnd()
14763 
        else:
14764 
          iprot.skip(ftype)
4910 phani.kuma 14765 
      else:
14766 
        iprot.skip(ftype)
14767 
      iprot.readFieldEnd()
14768 
    iprot.readStructEnd()
14769 
 
14770 
  def write(self, oprot):
14771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14773 
      return
14774 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
14775 
    if self.success is not None:
14776 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14777 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 14778 
      for iter315 in self.success:
14779 
        iter315.write(oprot)
4910 phani.kuma 14780 
      oprot.writeListEnd()
14781 
      oprot.writeFieldEnd()
14782 
    oprot.writeFieldStop()
14783 
    oprot.writeStructEnd()
14784 
 
14785 
  def validate(self):
14786 
    return
14787 
 
14788 
 
14789 
  def __repr__(self):
14790 
    L = ['%s=%r' % (key, value)
14791 
      for key, value in self.__dict__.iteritems()]
14792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14793 
 
14794 
  def __eq__(self, other):
14795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14796 
 
14797 
  def __ne__(self, other):
14798 
    return not (self == other)
14799 
 
14800 
class markOrdersAsLocalConnected_args:
14801 
  """
14802 
  Attributes:
14803 
   - providerId
14804 
   - local_connected_orders
14805 
  """
14806 
 
14807 
  thrift_spec = (
14808 
    None, # 0
14809 
    (1, TType.I64, 'providerId', None, None, ), # 1
14810 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
14811 
  )
14812 
 
14813 
  def __init__(self, providerId=None, local_connected_orders=None,):
14814 
    self.providerId = providerId
14815 
    self.local_connected_orders = local_connected_orders
14816 
 
14817 
  def read(self, iprot):
14818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14820 
      return
14821 
    iprot.readStructBegin()
14822 
    while True:
14823 
      (fname, ftype, fid) = iprot.readFieldBegin()
14824 
      if ftype == TType.STOP:
14825 
        break
14826 
      if fid == 1:
14827 
        if ftype == TType.I64:
14828 
          self.providerId = iprot.readI64();
14829 
        else:
14830 
          iprot.skip(ftype)
14831 
      elif fid == 2:
14832 
        if ftype == TType.MAP:
14833 
          self.local_connected_orders = {}
6031 rajveer 14834 
          (_ktype317, _vtype318, _size316 ) = iprot.readMapBegin()
14835 
          for _i320 in xrange(_size316):
14836 
            _key321 = iprot.readString();
14837 
            _val322 = iprot.readString();
14838 
            self.local_connected_orders[_key321] = _val322
4910 phani.kuma 14839 
          iprot.readMapEnd()
14840 
        else:
14841 
          iprot.skip(ftype)
14842 
      else:
14843 
        iprot.skip(ftype)
14844 
      iprot.readFieldEnd()
14845 
    iprot.readStructEnd()
14846 
 
14847 
  def write(self, oprot):
14848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14850 
      return
14851 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
14852 
    if self.providerId is not None:
14853 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14854 
      oprot.writeI64(self.providerId)
14855 
      oprot.writeFieldEnd()
14856 
    if self.local_connected_orders is not None:
14857 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
14858 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6031 rajveer 14859 
      for kiter323,viter324 in self.local_connected_orders.items():
14860 
        oprot.writeString(kiter323)
14861 
        oprot.writeString(viter324)
4910 phani.kuma 14862 
      oprot.writeMapEnd()
14863 
      oprot.writeFieldEnd()
14864 
    oprot.writeFieldStop()
14865 
    oprot.writeStructEnd()
14866 
 
14867 
  def validate(self):
14868 
    return
14869 
 
14870 
 
14871 
  def __repr__(self):
14872 
    L = ['%s=%r' % (key, value)
14873 
      for key, value in self.__dict__.iteritems()]
14874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14875 
 
14876 
  def __eq__(self, other):
14877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14878 
 
14879 
  def __ne__(self, other):
14880 
    return not (self == other)
14881 
 
14882 
class markOrdersAsLocalConnected_result:
14883 
  """
14884 
  Attributes:
14885 
   - ex
14886 
  """
14887 
 
14888 
  thrift_spec = (
14889 
    None, # 0
14890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14891 
  )
14892 
 
14893 
  def __init__(self, ex=None,):
14894 
    self.ex = ex
14895 
 
14896 
  def read(self, iprot):
14897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14899 
      return
14900 
    iprot.readStructBegin()
14901 
    while True:
14902 
      (fname, ftype, fid) = iprot.readFieldBegin()
14903 
      if ftype == TType.STOP:
14904 
        break
14905 
      if fid == 1:
3064 chandransh 14906 
        if ftype == TType.STRUCT:
14907 
          self.ex = TransactionServiceException()
14908 
          self.ex.read(iprot)
1627 ankur.sing 14909 
        else:
14910 
          iprot.skip(ftype)
14911 
      else:
14912 
        iprot.skip(ftype)
14913 
      iprot.readFieldEnd()
14914 
    iprot.readStructEnd()
14915 
 
14916 
  def write(self, oprot):
14917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14919 
      return
4910 phani.kuma 14920 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
14921 
    if self.ex is not None:
14922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14923 
      self.ex.write(oprot)
14924 
      oprot.writeFieldEnd()
14925 
    oprot.writeFieldStop()
14926 
    oprot.writeStructEnd()
14927 
 
14928 
  def validate(self):
14929 
    return
14930 
 
14931 
 
14932 
  def __repr__(self):
14933 
    L = ['%s=%r' % (key, value)
14934 
      for key, value in self.__dict__.iteritems()]
14935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14936 
 
14937 
  def __eq__(self, other):
14938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14939 
 
14940 
  def __ne__(self, other):
14941 
    return not (self == other)
14942 
 
14943 
class getOrdersNotLocalConnected_args:
14944 
  """
14945 
  Attributes:
14946 
   - providerId
14947 
  """
14948 
 
14949 
  thrift_spec = (
14950 
    None, # 0
14951 
    (1, TType.I64, 'providerId', None, None, ), # 1
14952 
  )
14953 
 
14954 
  def __init__(self, providerId=None,):
14955 
    self.providerId = providerId
14956 
 
14957 
  def read(self, iprot):
14958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14960 
      return
14961 
    iprot.readStructBegin()
14962 
    while True:
14963 
      (fname, ftype, fid) = iprot.readFieldBegin()
14964 
      if ftype == TType.STOP:
14965 
        break
14966 
      if fid == 1:
14967 
        if ftype == TType.I64:
14968 
          self.providerId = iprot.readI64();
14969 
        else:
14970 
          iprot.skip(ftype)
14971 
      else:
14972 
        iprot.skip(ftype)
14973 
      iprot.readFieldEnd()
14974 
    iprot.readStructEnd()
14975 
 
14976 
  def write(self, oprot):
14977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14979 
      return
14980 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
14981 
    if self.providerId is not None:
14982 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14983 
      oprot.writeI64(self.providerId)
14984 
      oprot.writeFieldEnd()
14985 
    oprot.writeFieldStop()
14986 
    oprot.writeStructEnd()
14987 
 
14988 
  def validate(self):
14989 
    return
14990 
 
14991 
 
14992 
  def __repr__(self):
14993 
    L = ['%s=%r' % (key, value)
14994 
      for key, value in self.__dict__.iteritems()]
14995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14996 
 
14997 
  def __eq__(self, other):
14998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14999 
 
15000 
  def __ne__(self, other):
15001 
    return not (self == other)
15002 
 
15003 
class getOrdersNotLocalConnected_result:
15004 
  """
15005 
  Attributes:
15006 
   - success
15007 
  """
15008 
 
15009 
  thrift_spec = (
15010 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15011 
  )
15012 
 
15013 
  def __init__(self, success=None,):
15014 
    self.success = success
15015 
 
15016 
  def read(self, iprot):
15017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15019 
      return
15020 
    iprot.readStructBegin()
15021 
    while True:
15022 
      (fname, ftype, fid) = iprot.readFieldBegin()
15023 
      if ftype == TType.STOP:
15024 
        break
15025 
      if fid == 0:
15026 
        if ftype == TType.LIST:
15027 
          self.success = []
6031 rajveer 15028 
          (_etype328, _size325) = iprot.readListBegin()
15029 
          for _i329 in xrange(_size325):
15030 
            _elem330 = Order()
15031 
            _elem330.read(iprot)
15032 
            self.success.append(_elem330)
4910 phani.kuma 15033 
          iprot.readListEnd()
15034 
        else:
15035 
          iprot.skip(ftype)
15036 
      else:
15037 
        iprot.skip(ftype)
15038 
      iprot.readFieldEnd()
15039 
    iprot.readStructEnd()
15040 
 
15041 
  def write(self, oprot):
15042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15044 
      return
15045 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15046 
    if self.success is not None:
15047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15048 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15049 
      for iter331 in self.success:
15050 
        iter331.write(oprot)
4581 phani.kuma 15051 
      oprot.writeListEnd()
15052 
      oprot.writeFieldEnd()
4910 phani.kuma 15053 
    oprot.writeFieldStop()
15054 
    oprot.writeStructEnd()
15055 
 
15056 
  def validate(self):
15057 
    return
15058 
 
15059 
 
15060 
  def __repr__(self):
15061 
    L = ['%s=%r' % (key, value)
15062 
      for key, value in self.__dict__.iteritems()]
15063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15064 
 
15065 
  def __eq__(self, other):
15066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15067 
 
15068 
  def __ne__(self, other):
15069 
    return not (self == other)
15070 
 
15071 
class markOrdersAsDestinationCityReached_args:
15072 
  """
15073 
  Attributes:
15074 
   - providerId
15075 
   - destination_city_reached_orders
15076 
  """
15077 
 
15078 
  thrift_spec = (
15079 
    None, # 0
15080 
    (1, TType.I64, 'providerId', None, None, ), # 1
15081 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15082 
  )
15083 
 
15084 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15085 
    self.providerId = providerId
15086 
    self.destination_city_reached_orders = destination_city_reached_orders
15087 
 
15088 
  def read(self, iprot):
15089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15091 
      return
15092 
    iprot.readStructBegin()
15093 
    while True:
15094 
      (fname, ftype, fid) = iprot.readFieldBegin()
15095 
      if ftype == TType.STOP:
15096 
        break
15097 
      if fid == 1:
15098 
        if ftype == TType.I64:
15099 
          self.providerId = iprot.readI64();
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      elif fid == 2:
15103 
        if ftype == TType.MAP:
15104 
          self.destination_city_reached_orders = {}
6031 rajveer 15105 
          (_ktype333, _vtype334, _size332 ) = iprot.readMapBegin()
15106 
          for _i336 in xrange(_size332):
15107 
            _key337 = iprot.readString();
15108 
            _val338 = iprot.readString();
15109 
            self.destination_city_reached_orders[_key337] = _val338
4910 phani.kuma 15110 
          iprot.readMapEnd()
15111 
        else:
15112 
          iprot.skip(ftype)
15113 
      else:
15114 
        iprot.skip(ftype)
15115 
      iprot.readFieldEnd()
15116 
    iprot.readStructEnd()
15117 
 
15118 
  def write(self, oprot):
15119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15121 
      return
15122 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15123 
    if self.providerId is not None:
15124 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15125 
      oprot.writeI64(self.providerId)
15126 
      oprot.writeFieldEnd()
15127 
    if self.destination_city_reached_orders is not None:
15128 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15129 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6031 rajveer 15130 
      for kiter339,viter340 in self.destination_city_reached_orders.items():
15131 
        oprot.writeString(kiter339)
15132 
        oprot.writeString(viter340)
4910 phani.kuma 15133 
      oprot.writeMapEnd()
15134 
      oprot.writeFieldEnd()
15135 
    oprot.writeFieldStop()
15136 
    oprot.writeStructEnd()
15137 
 
15138 
  def validate(self):
15139 
    return
15140 
 
15141 
 
15142 
  def __repr__(self):
15143 
    L = ['%s=%r' % (key, value)
15144 
      for key, value in self.__dict__.iteritems()]
15145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15146 
 
15147 
  def __eq__(self, other):
15148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15149 
 
15150 
  def __ne__(self, other):
15151 
    return not (self == other)
15152 
 
15153 
class markOrdersAsDestinationCityReached_result:
15154 
  """
15155 
  Attributes:
15156 
   - ex
15157 
  """
15158 
 
15159 
  thrift_spec = (
15160 
    None, # 0
15161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15162 
  )
15163 
 
15164 
  def __init__(self, ex=None,):
15165 
    self.ex = ex
15166 
 
15167 
  def read(self, iprot):
15168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15170 
      return
15171 
    iprot.readStructBegin()
15172 
    while True:
15173 
      (fname, ftype, fid) = iprot.readFieldBegin()
15174 
      if ftype == TType.STOP:
15175 
        break
15176 
      if fid == 1:
15177 
        if ftype == TType.STRUCT:
15178 
          self.ex = TransactionServiceException()
15179 
          self.ex.read(iprot)
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      else:
15183 
        iprot.skip(ftype)
15184 
      iprot.readFieldEnd()
15185 
    iprot.readStructEnd()
15186 
 
15187 
  def write(self, oprot):
15188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15190 
      return
15191 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15192 
    if self.ex is not None:
3064 chandransh 15193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15194 
      self.ex.write(oprot)
1627 ankur.sing 15195 
      oprot.writeFieldEnd()
15196 
    oprot.writeFieldStop()
15197 
    oprot.writeStructEnd()
15198 
 
3431 rajveer 15199 
  def validate(self):
15200 
    return
15201 
 
15202 
 
1627 ankur.sing 15203 
  def __repr__(self):
15204 
    L = ['%s=%r' % (key, value)
15205 
      for key, value in self.__dict__.iteritems()]
15206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15207 
 
15208 
  def __eq__(self, other):
15209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15210 
 
15211 
  def __ne__(self, other):
15212 
    return not (self == other)
15213 
 
4910 phani.kuma 15214 
class markOrdersAsFirstDeliveryAttempted_args:
15215 
  """
15216 
  Attributes:
15217 
   - providerId
15218 
   - first_atdl_orders
15219 
  """
15220 
 
15221 
  thrift_spec = (
15222 
    None, # 0
15223 
    (1, TType.I64, 'providerId', None, None, ), # 1
15224 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15225 
  )
15226 
 
15227 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15228 
    self.providerId = providerId
15229 
    self.first_atdl_orders = first_atdl_orders
15230 
 
15231 
  def read(self, iprot):
15232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15234 
      return
15235 
    iprot.readStructBegin()
15236 
    while True:
15237 
      (fname, ftype, fid) = iprot.readFieldBegin()
15238 
      if ftype == TType.STOP:
15239 
        break
15240 
      if fid == 1:
15241 
        if ftype == TType.I64:
15242 
          self.providerId = iprot.readI64();
15243 
        else:
15244 
          iprot.skip(ftype)
15245 
      elif fid == 2:
15246 
        if ftype == TType.MAP:
15247 
          self.first_atdl_orders = {}
6031 rajveer 15248 
          (_ktype342, _vtype343, _size341 ) = iprot.readMapBegin()
15249 
          for _i345 in xrange(_size341):
15250 
            _key346 = iprot.readString();
15251 
            _val347 = iprot.readString();
15252 
            self.first_atdl_orders[_key346] = _val347
4910 phani.kuma 15253 
          iprot.readMapEnd()
15254 
        else:
15255 
          iprot.skip(ftype)
15256 
      else:
15257 
        iprot.skip(ftype)
15258 
      iprot.readFieldEnd()
15259 
    iprot.readStructEnd()
15260 
 
15261 
  def write(self, oprot):
15262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15264 
      return
15265 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15266 
    if self.providerId is not None:
15267 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15268 
      oprot.writeI64(self.providerId)
15269 
      oprot.writeFieldEnd()
15270 
    if self.first_atdl_orders is not None:
15271 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15272 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6031 rajveer 15273 
      for kiter348,viter349 in self.first_atdl_orders.items():
15274 
        oprot.writeString(kiter348)
15275 
        oprot.writeString(viter349)
4910 phani.kuma 15276 
      oprot.writeMapEnd()
15277 
      oprot.writeFieldEnd()
15278 
    oprot.writeFieldStop()
15279 
    oprot.writeStructEnd()
15280 
 
15281 
  def validate(self):
15282 
    return
15283 
 
15284 
 
15285 
  def __repr__(self):
15286 
    L = ['%s=%r' % (key, value)
15287 
      for key, value in self.__dict__.iteritems()]
15288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15289 
 
15290 
  def __eq__(self, other):
15291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15292 
 
15293 
  def __ne__(self, other):
15294 
    return not (self == other)
15295 
 
15296 
class markOrdersAsFirstDeliveryAttempted_result:
15297 
  """
15298 
  Attributes:
15299 
   - ex
15300 
  """
15301 
 
15302 
  thrift_spec = (
15303 
    None, # 0
15304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15305 
  )
15306 
 
15307 
  def __init__(self, ex=None,):
15308 
    self.ex = ex
15309 
 
15310 
  def read(self, iprot):
15311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15313 
      return
15314 
    iprot.readStructBegin()
15315 
    while True:
15316 
      (fname, ftype, fid) = iprot.readFieldBegin()
15317 
      if ftype == TType.STOP:
15318 
        break
15319 
      if fid == 1:
15320 
        if ftype == TType.STRUCT:
15321 
          self.ex = TransactionServiceException()
15322 
          self.ex.read(iprot)
15323 
        else:
15324 
          iprot.skip(ftype)
15325 
      else:
15326 
        iprot.skip(ftype)
15327 
      iprot.readFieldEnd()
15328 
    iprot.readStructEnd()
15329 
 
15330 
  def write(self, oprot):
15331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15333 
      return
15334 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15335 
    if self.ex is not None:
15336 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15337 
      self.ex.write(oprot)
15338 
      oprot.writeFieldEnd()
15339 
    oprot.writeFieldStop()
15340 
    oprot.writeStructEnd()
15341 
 
15342 
  def validate(self):
15343 
    return
15344 
 
15345 
 
15346 
  def __repr__(self):
15347 
    L = ['%s=%r' % (key, value)
15348 
      for key, value in self.__dict__.iteritems()]
15349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15350 
 
15351 
  def __eq__(self, other):
15352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15353 
 
15354 
  def __ne__(self, other):
15355 
    return not (self == other)
15356 
 
3064 chandransh 15357 
class getUndeliveredOrders_args:
1886 ankur.sing 15358 
  """
15359 
  Attributes:
3064 chandransh 15360 
   - providerId
15361 
   - warehouseId
1886 ankur.sing 15362 
  """
1627 ankur.sing 15363 
 
1886 ankur.sing 15364 
  thrift_spec = (
15365 
    None, # 0
3064 chandransh 15366 
    (1, TType.I64, 'providerId', None, None, ), # 1
15367 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15368 
  )
15369 
 
3064 chandransh 15370 
  def __init__(self, providerId=None, warehouseId=None,):
15371 
    self.providerId = providerId
15372 
    self.warehouseId = warehouseId
1886 ankur.sing 15373 
 
15374 
  def read(self, iprot):
15375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15377 
      return
15378 
    iprot.readStructBegin()
15379 
    while True:
15380 
      (fname, ftype, fid) = iprot.readFieldBegin()
15381 
      if ftype == TType.STOP:
15382 
        break
15383 
      if fid == 1:
15384 
        if ftype == TType.I64:
3064 chandransh 15385 
          self.providerId = iprot.readI64();
1886 ankur.sing 15386 
        else:
15387 
          iprot.skip(ftype)
3064 chandransh 15388 
      elif fid == 2:
15389 
        if ftype == TType.I64:
15390 
          self.warehouseId = iprot.readI64();
15391 
        else:
15392 
          iprot.skip(ftype)
1886 ankur.sing 15393 
      else:
15394 
        iprot.skip(ftype)
15395 
      iprot.readFieldEnd()
15396 
    iprot.readStructEnd()
15397 
 
15398 
  def write(self, oprot):
15399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15401 
      return
3064 chandransh 15402 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15403 
    if self.providerId is not None:
3064 chandransh 15404 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15405 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15406 
      oprot.writeFieldEnd()
3431 rajveer 15407 
    if self.warehouseId is not None:
3064 chandransh 15408 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15409 
      oprot.writeI64(self.warehouseId)
15410 
      oprot.writeFieldEnd()
1886 ankur.sing 15411 
    oprot.writeFieldStop()
15412 
    oprot.writeStructEnd()
15413 
 
3431 rajveer 15414 
  def validate(self):
15415 
    return
15416 
 
15417 
 
1886 ankur.sing 15418 
  def __repr__(self):
15419 
    L = ['%s=%r' % (key, value)
15420 
      for key, value in self.__dict__.iteritems()]
15421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15422 
 
15423 
  def __eq__(self, other):
15424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15425 
 
15426 
  def __ne__(self, other):
15427 
    return not (self == other)
15428 
 
3064 chandransh 15429 
class getUndeliveredOrders_result:
1886 ankur.sing 15430 
  """
15431 
  Attributes:
15432 
   - success
15433 
  """
15434 
 
15435 
  thrift_spec = (
15436 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15437 
  )
15438 
 
15439 
  def __init__(self, success=None,):
15440 
    self.success = success
15441 
 
15442 
  def read(self, iprot):
15443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15445 
      return
15446 
    iprot.readStructBegin()
15447 
    while True:
15448 
      (fname, ftype, fid) = iprot.readFieldBegin()
15449 
      if ftype == TType.STOP:
15450 
        break
15451 
      if fid == 0:
15452 
        if ftype == TType.LIST:
15453 
          self.success = []
6031 rajveer 15454 
          (_etype353, _size350) = iprot.readListBegin()
15455 
          for _i354 in xrange(_size350):
15456 
            _elem355 = Order()
15457 
            _elem355.read(iprot)
15458 
            self.success.append(_elem355)
1886 ankur.sing 15459 
          iprot.readListEnd()
15460 
        else:
15461 
          iprot.skip(ftype)
15462 
      else:
15463 
        iprot.skip(ftype)
15464 
      iprot.readFieldEnd()
15465 
    iprot.readStructEnd()
15466 
 
15467 
  def write(self, oprot):
15468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15470 
      return
3064 chandransh 15471 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15472 
    if self.success is not None:
1886 ankur.sing 15473 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15474 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15475 
      for iter356 in self.success:
15476 
        iter356.write(oprot)
1886 ankur.sing 15477 
      oprot.writeListEnd()
15478 
      oprot.writeFieldEnd()
15479 
    oprot.writeFieldStop()
15480 
    oprot.writeStructEnd()
15481 
 
3431 rajveer 15482 
  def validate(self):
15483 
    return
15484 
 
15485 
 
1886 ankur.sing 15486 
  def __repr__(self):
15487 
    L = ['%s=%r' % (key, value)
15488 
      for key, value in self.__dict__.iteritems()]
15489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15490 
 
15491 
  def __eq__(self, other):
15492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15493 
 
15494 
  def __ne__(self, other):
15495 
    return not (self == other)
15496 
 
4783 phani.kuma 15497 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15498 
 
15499 
  thrift_spec = (
15500 
  )
15501 
 
15502 
  def read(self, iprot):
15503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15505 
      return
15506 
    iprot.readStructBegin()
15507 
    while True:
15508 
      (fname, ftype, fid) = iprot.readFieldBegin()
15509 
      if ftype == TType.STOP:
15510 
        break
15511 
      else:
15512 
        iprot.skip(ftype)
15513 
      iprot.readFieldEnd()
15514 
    iprot.readStructEnd()
15515 
 
15516 
  def write(self, oprot):
15517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15519 
      return
15520 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15521 
    oprot.writeFieldStop()
15522 
    oprot.writeStructEnd()
15523 
 
15524 
  def validate(self):
15525 
    return
15526 
 
15527 
 
15528 
  def __repr__(self):
15529 
    L = ['%s=%r' % (key, value)
15530 
      for key, value in self.__dict__.iteritems()]
15531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15532 
 
15533 
  def __eq__(self, other):
15534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15535 
 
15536 
  def __ne__(self, other):
15537 
    return not (self == other)
15538 
 
15539 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15540 
  """
15541 
  Attributes:
15542 
   - success
15543 
  """
15544 
 
15545 
  thrift_spec = (
15546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15547 
  )
15548 
 
15549 
  def __init__(self, success=None,):
15550 
    self.success = success
15551 
 
15552 
  def read(self, iprot):
15553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15555 
      return
15556 
    iprot.readStructBegin()
15557 
    while True:
15558 
      (fname, ftype, fid) = iprot.readFieldBegin()
15559 
      if ftype == TType.STOP:
15560 
        break
15561 
      if fid == 0:
15562 
        if ftype == TType.LIST:
15563 
          self.success = []
6031 rajveer 15564 
          (_etype360, _size357) = iprot.readListBegin()
15565 
          for _i361 in xrange(_size357):
15566 
            _elem362 = Order()
15567 
            _elem362.read(iprot)
15568 
            self.success.append(_elem362)
4783 phani.kuma 15569 
          iprot.readListEnd()
15570 
        else:
15571 
          iprot.skip(ftype)
15572 
      else:
15573 
        iprot.skip(ftype)
15574 
      iprot.readFieldEnd()
15575 
    iprot.readStructEnd()
15576 
 
15577 
  def write(self, oprot):
15578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15580 
      return
15581 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15582 
    if self.success is not None:
15583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15584 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 15585 
      for iter363 in self.success:
15586 
        iter363.write(oprot)
4783 phani.kuma 15587 
      oprot.writeListEnd()
15588 
      oprot.writeFieldEnd()
15589 
    oprot.writeFieldStop()
15590 
    oprot.writeStructEnd()
15591 
 
15592 
  def validate(self):
15593 
    return
15594 
 
15595 
 
15596 
  def __repr__(self):
15597 
    L = ['%s=%r' % (key, value)
15598 
      for key, value in self.__dict__.iteritems()]
15599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15600 
 
15601 
  def __eq__(self, other):
15602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15603 
 
15604 
  def __ne__(self, other):
15605 
    return not (self == other)
15606 
 
2536 chandransh 15607 
class toggleDOAFlag_args:
15608 
  """
15609 
  Attributes:
15610 
   - orderId
15611 
  """
1886 ankur.sing 15612 
 
2536 chandransh 15613 
  thrift_spec = (
15614 
    None, # 0
15615 
    (1, TType.I64, 'orderId', None, None, ), # 1
15616 
  )
15617 
 
15618 
  def __init__(self, orderId=None,):
15619 
    self.orderId = orderId
15620 
 
15621 
  def read(self, iprot):
15622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15624 
      return
15625 
    iprot.readStructBegin()
15626 
    while True:
15627 
      (fname, ftype, fid) = iprot.readFieldBegin()
15628 
      if ftype == TType.STOP:
15629 
        break
15630 
      if fid == 1:
15631 
        if ftype == TType.I64:
15632 
          self.orderId = iprot.readI64();
15633 
        else:
15634 
          iprot.skip(ftype)
15635 
      else:
15636 
        iprot.skip(ftype)
15637 
      iprot.readFieldEnd()
15638 
    iprot.readStructEnd()
15639 
 
15640 
  def write(self, oprot):
15641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15643 
      return
15644 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15645 
    if self.orderId is not None:
2536 chandransh 15646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15647 
      oprot.writeI64(self.orderId)
15648 
      oprot.writeFieldEnd()
15649 
    oprot.writeFieldStop()
15650 
    oprot.writeStructEnd()
15651 
 
3431 rajveer 15652 
  def validate(self):
15653 
    return
15654 
 
15655 
 
2536 chandransh 15656 
  def __repr__(self):
15657 
    L = ['%s=%r' % (key, value)
15658 
      for key, value in self.__dict__.iteritems()]
15659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15660 
 
15661 
  def __eq__(self, other):
15662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15663 
 
15664 
  def __ne__(self, other):
15665 
    return not (self == other)
15666 
 
15667 
class toggleDOAFlag_result:
15668 
  """
15669 
  Attributes:
15670 
   - success
15671 
   - ex
15672 
  """
15673 
 
15674 
  thrift_spec = (
15675 
    (0, TType.BOOL, 'success', None, None, ), # 0
15676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15677 
  )
15678 
 
15679 
  def __init__(self, success=None, ex=None,):
15680 
    self.success = success
15681 
    self.ex = ex
15682 
 
15683 
  def read(self, iprot):
15684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15686 
      return
15687 
    iprot.readStructBegin()
15688 
    while True:
15689 
      (fname, ftype, fid) = iprot.readFieldBegin()
15690 
      if ftype == TType.STOP:
15691 
        break
15692 
      if fid == 0:
15693 
        if ftype == TType.BOOL:
15694 
          self.success = iprot.readBool();
15695 
        else:
15696 
          iprot.skip(ftype)
15697 
      elif fid == 1:
15698 
        if ftype == TType.STRUCT:
15699 
          self.ex = TransactionServiceException()
15700 
          self.ex.read(iprot)
15701 
        else:
15702 
          iprot.skip(ftype)
15703 
      else:
15704 
        iprot.skip(ftype)
15705 
      iprot.readFieldEnd()
15706 
    iprot.readStructEnd()
15707 
 
15708 
  def write(self, oprot):
15709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15711 
      return
15712 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15713 
    if self.success is not None:
2536 chandransh 15714 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15715 
      oprot.writeBool(self.success)
15716 
      oprot.writeFieldEnd()
3431 rajveer 15717 
    if self.ex is not None:
2536 chandransh 15718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15719 
      self.ex.write(oprot)
15720 
      oprot.writeFieldEnd()
15721 
    oprot.writeFieldStop()
15722 
    oprot.writeStructEnd()
15723 
 
3431 rajveer 15724 
  def validate(self):
15725 
    return
15726 
 
15727 
 
2536 chandransh 15728 
  def __repr__(self):
15729 
    L = ['%s=%r' % (key, value)
15730 
      for key, value in self.__dict__.iteritems()]
15731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15732 
 
15733 
  def __eq__(self, other):
15734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15735 
 
15736 
  def __ne__(self, other):
15737 
    return not (self == other)
15738 
 
4712 rajveer 15739 
class markOrderAsDelivered_args:
15740 
  """
15741 
  Attributes:
15742 
   - orderId
15743 
   - deliveryTimestamp
15744 
   - receiver
15745 
  """
15746 
 
15747 
  thrift_spec = None
15748 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
15749 
    self.orderId = orderId
15750 
    self.deliveryTimestamp = deliveryTimestamp
15751 
    self.receiver = receiver
15752 
 
15753 
  def read(self, iprot):
15754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15756 
      return
15757 
    iprot.readStructBegin()
15758 
    while True:
15759 
      (fname, ftype, fid) = iprot.readFieldBegin()
15760 
      if ftype == TType.STOP:
15761 
        break
15762 
      if fid == 1:
15763 
        if ftype == TType.I64:
15764 
          self.orderId = iprot.readI64();
15765 
        else:
15766 
          iprot.skip(ftype)
15767 
      elif fid == 2:
15768 
        if ftype == TType.I64:
15769 
          self.deliveryTimestamp = iprot.readI64();
15770 
        else:
15771 
          iprot.skip(ftype)
15772 
      elif fid == -1:
15773 
        if ftype == TType.STRING:
15774 
          self.receiver = iprot.readString();
15775 
        else:
15776 
          iprot.skip(ftype)
15777 
      else:
15778 
        iprot.skip(ftype)
15779 
      iprot.readFieldEnd()
15780 
    iprot.readStructEnd()
15781 
 
15782 
  def write(self, oprot):
15783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15785 
      return
15786 
    oprot.writeStructBegin('markOrderAsDelivered_args')
15787 
    if self.receiver is not None:
15788 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
15789 
      oprot.writeString(self.receiver)
15790 
      oprot.writeFieldEnd()
15791 
    if self.orderId is not None:
15792 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15793 
      oprot.writeI64(self.orderId)
15794 
      oprot.writeFieldEnd()
15795 
    if self.deliveryTimestamp is not None:
15796 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15797 
      oprot.writeI64(self.deliveryTimestamp)
15798 
      oprot.writeFieldEnd()
15799 
    oprot.writeFieldStop()
15800 
    oprot.writeStructEnd()
15801 
 
15802 
  def validate(self):
15803 
    return
15804 
 
15805 
 
15806 
  def __repr__(self):
15807 
    L = ['%s=%r' % (key, value)
15808 
      for key, value in self.__dict__.iteritems()]
15809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15810 
 
15811 
  def __eq__(self, other):
15812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15813 
 
15814 
  def __ne__(self, other):
15815 
    return not (self == other)
15816 
 
15817 
class markOrderAsDelivered_result:
15818 
  """
15819 
  Attributes:
15820 
   - ex
15821 
  """
15822 
 
15823 
  thrift_spec = (
15824 
    None, # 0
15825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15826 
  )
15827 
 
15828 
  def __init__(self, ex=None,):
15829 
    self.ex = ex
15830 
 
15831 
  def read(self, iprot):
15832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15834 
      return
15835 
    iprot.readStructBegin()
15836 
    while True:
15837 
      (fname, ftype, fid) = iprot.readFieldBegin()
15838 
      if ftype == TType.STOP:
15839 
        break
15840 
      if fid == 1:
15841 
        if ftype == TType.STRUCT:
15842 
          self.ex = TransactionServiceException()
15843 
          self.ex.read(iprot)
15844 
        else:
15845 
          iprot.skip(ftype)
15846 
      else:
15847 
        iprot.skip(ftype)
15848 
      iprot.readFieldEnd()
15849 
    iprot.readStructEnd()
15850 
 
15851 
  def write(self, oprot):
15852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15854 
      return
15855 
    oprot.writeStructBegin('markOrderAsDelivered_result')
15856 
    if self.ex is not None:
15857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15858 
      self.ex.write(oprot)
15859 
      oprot.writeFieldEnd()
15860 
    oprot.writeFieldStop()
15861 
    oprot.writeStructEnd()
15862 
 
15863 
  def validate(self):
15864 
    return
15865 
 
15866 
 
15867 
  def __repr__(self):
15868 
    L = ['%s=%r' % (key, value)
15869 
      for key, value in self.__dict__.iteritems()]
15870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15871 
 
15872 
  def __eq__(self, other):
15873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15874 
 
15875 
  def __ne__(self, other):
15876 
    return not (self == other)
15877 
 
5553 rajveer 15878 
class markOrderAsReceivedAtStore_args:
15879 
  """
15880 
  Attributes:
15881 
   - orderId
15882 
   - deliveryTimestamp
15883 
  """
15884 
 
15885 
  thrift_spec = (
15886 
    None, # 0
15887 
    (1, TType.I64, 'orderId', None, None, ), # 1
15888 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
15889 
  )
15890 
 
15891 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
15892 
    self.orderId = orderId
15893 
    self.deliveryTimestamp = deliveryTimestamp
15894 
 
15895 
  def read(self, iprot):
15896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15898 
      return
15899 
    iprot.readStructBegin()
15900 
    while True:
15901 
      (fname, ftype, fid) = iprot.readFieldBegin()
15902 
      if ftype == TType.STOP:
15903 
        break
15904 
      if fid == 1:
15905 
        if ftype == TType.I64:
15906 
          self.orderId = iprot.readI64();
15907 
        else:
15908 
          iprot.skip(ftype)
15909 
      elif fid == 2:
15910 
        if ftype == TType.I64:
15911 
          self.deliveryTimestamp = iprot.readI64();
15912 
        else:
15913 
          iprot.skip(ftype)
15914 
      else:
15915 
        iprot.skip(ftype)
15916 
      iprot.readFieldEnd()
15917 
    iprot.readStructEnd()
15918 
 
15919 
  def write(self, oprot):
15920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15922 
      return
15923 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
15924 
    if self.orderId is not None:
15925 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15926 
      oprot.writeI64(self.orderId)
15927 
      oprot.writeFieldEnd()
15928 
    if self.deliveryTimestamp is not None:
15929 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
15930 
      oprot.writeI64(self.deliveryTimestamp)
15931 
      oprot.writeFieldEnd()
15932 
    oprot.writeFieldStop()
15933 
    oprot.writeStructEnd()
15934 
 
15935 
  def validate(self):
15936 
    return
15937 
 
15938 
 
15939 
  def __repr__(self):
15940 
    L = ['%s=%r' % (key, value)
15941 
      for key, value in self.__dict__.iteritems()]
15942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15943 
 
15944 
  def __eq__(self, other):
15945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15946 
 
15947 
  def __ne__(self, other):
15948 
    return not (self == other)
15949 
 
15950 
class markOrderAsReceivedAtStore_result:
15951 
  """
15952 
  Attributes:
15953 
   - ex
15954 
  """
15955 
 
15956 
  thrift_spec = (
15957 
    None, # 0
15958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15959 
  )
15960 
 
15961 
  def __init__(self, ex=None,):
15962 
    self.ex = ex
15963 
 
15964 
  def read(self, iprot):
15965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15967 
      return
15968 
    iprot.readStructBegin()
15969 
    while True:
15970 
      (fname, ftype, fid) = iprot.readFieldBegin()
15971 
      if ftype == TType.STOP:
15972 
        break
15973 
      if fid == 1:
15974 
        if ftype == TType.STRUCT:
15975 
          self.ex = TransactionServiceException()
15976 
          self.ex.read(iprot)
15977 
        else:
15978 
          iprot.skip(ftype)
15979 
      else:
15980 
        iprot.skip(ftype)
15981 
      iprot.readFieldEnd()
15982 
    iprot.readStructEnd()
15983 
 
15984 
  def write(self, oprot):
15985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15987 
      return
15988 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
15989 
    if self.ex is not None:
15990 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15991 
      self.ex.write(oprot)
15992 
      oprot.writeFieldEnd()
15993 
    oprot.writeFieldStop()
15994 
    oprot.writeStructEnd()
15995 
 
15996 
  def validate(self):
15997 
    return
15998 
 
15999 
 
16000 
  def __repr__(self):
16001 
    L = ['%s=%r' % (key, value)
16002 
      for key, value in self.__dict__.iteritems()]
16003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16004 
 
16005 
  def __eq__(self, other):
16006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16007 
 
16008 
  def __ne__(self, other):
16009 
    return not (self == other)
16010 
 
4454 rajveer 16011 
class markOrderDoaRequestReceived_args:
16012 
  """
16013 
  Attributes:
16014 
   - orderId
16015 
  """
16016 
 
16017 
  thrift_spec = (
16018 
    None, # 0
16019 
    (1, TType.I64, 'orderId', None, None, ), # 1
16020 
  )
16021 
 
16022 
  def __init__(self, orderId=None,):
16023 
    self.orderId = orderId
16024 
 
16025 
  def read(self, iprot):
16026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16028 
      return
16029 
    iprot.readStructBegin()
16030 
    while True:
16031 
      (fname, ftype, fid) = iprot.readFieldBegin()
16032 
      if ftype == TType.STOP:
16033 
        break
16034 
      if fid == 1:
16035 
        if ftype == TType.I64:
16036 
          self.orderId = iprot.readI64();
16037 
        else:
16038 
          iprot.skip(ftype)
16039 
      else:
16040 
        iprot.skip(ftype)
16041 
      iprot.readFieldEnd()
16042 
    iprot.readStructEnd()
16043 
 
16044 
  def write(self, oprot):
16045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16047 
      return
16048 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16049 
    if self.orderId is not None:
16050 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16051 
      oprot.writeI64(self.orderId)
16052 
      oprot.writeFieldEnd()
16053 
    oprot.writeFieldStop()
16054 
    oprot.writeStructEnd()
16055 
 
16056 
  def validate(self):
16057 
    return
16058 
 
16059 
 
16060 
  def __repr__(self):
16061 
    L = ['%s=%r' % (key, value)
16062 
      for key, value in self.__dict__.iteritems()]
16063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16064 
 
16065 
  def __eq__(self, other):
16066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16067 
 
16068 
  def __ne__(self, other):
16069 
    return not (self == other)
16070 
 
16071 
class markOrderDoaRequestReceived_result:
16072 
  """
16073 
  Attributes:
16074 
   - success
16075 
   - ex
16076 
  """
16077 
 
16078 
  thrift_spec = (
16079 
    (0, TType.BOOL, 'success', None, None, ), # 0
16080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16081 
  )
16082 
 
16083 
  def __init__(self, success=None, ex=None,):
16084 
    self.success = success
16085 
    self.ex = ex
16086 
 
16087 
  def read(self, iprot):
16088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16090 
      return
16091 
    iprot.readStructBegin()
16092 
    while True:
16093 
      (fname, ftype, fid) = iprot.readFieldBegin()
16094 
      if ftype == TType.STOP:
16095 
        break
16096 
      if fid == 0:
16097 
        if ftype == TType.BOOL:
16098 
          self.success = iprot.readBool();
16099 
        else:
16100 
          iprot.skip(ftype)
16101 
      elif fid == 1:
16102 
        if ftype == TType.STRUCT:
16103 
          self.ex = TransactionServiceException()
16104 
          self.ex.read(iprot)
16105 
        else:
16106 
          iprot.skip(ftype)
16107 
      else:
16108 
        iprot.skip(ftype)
16109 
      iprot.readFieldEnd()
16110 
    iprot.readStructEnd()
16111 
 
16112 
  def write(self, oprot):
16113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16115 
      return
16116 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16117 
    if self.success is not None:
16118 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16119 
      oprot.writeBool(self.success)
16120 
      oprot.writeFieldEnd()
16121 
    if self.ex is not None:
16122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16123 
      self.ex.write(oprot)
16124 
      oprot.writeFieldEnd()
16125 
    oprot.writeFieldStop()
16126 
    oprot.writeStructEnd()
16127 
 
16128 
  def validate(self):
16129 
    return
16130 
 
16131 
 
16132 
  def __repr__(self):
16133 
    L = ['%s=%r' % (key, value)
16134 
      for key, value in self.__dict__.iteritems()]
16135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16136 
 
16137 
  def __eq__(self, other):
16138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16139 
 
16140 
  def __ne__(self, other):
16141 
    return not (self == other)
16142 
 
16143 
class markOrderDoaRequestAuthorized_args:
16144 
  """
16145 
  Attributes:
16146 
   - orderId
16147 
   - isAuthorized
16148 
  """
16149 
 
16150 
  thrift_spec = (
16151 
    None, # 0
16152 
    (1, TType.I64, 'orderId', None, None, ), # 1
16153 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16154 
  )
16155 
 
16156 
  def __init__(self, orderId=None, isAuthorized=None,):
16157 
    self.orderId = orderId
16158 
    self.isAuthorized = isAuthorized
16159 
 
16160 
  def read(self, iprot):
16161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16163 
      return
16164 
    iprot.readStructBegin()
16165 
    while True:
16166 
      (fname, ftype, fid) = iprot.readFieldBegin()
16167 
      if ftype == TType.STOP:
16168 
        break
16169 
      if fid == 1:
16170 
        if ftype == TType.I64:
16171 
          self.orderId = iprot.readI64();
16172 
        else:
16173 
          iprot.skip(ftype)
16174 
      elif fid == 2:
16175 
        if ftype == TType.BOOL:
16176 
          self.isAuthorized = iprot.readBool();
16177 
        else:
16178 
          iprot.skip(ftype)
16179 
      else:
16180 
        iprot.skip(ftype)
16181 
      iprot.readFieldEnd()
16182 
    iprot.readStructEnd()
16183 
 
16184 
  def write(self, oprot):
16185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16187 
      return
16188 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16189 
    if self.orderId is not None:
16190 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16191 
      oprot.writeI64(self.orderId)
16192 
      oprot.writeFieldEnd()
16193 
    if self.isAuthorized is not None:
16194 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16195 
      oprot.writeBool(self.isAuthorized)
16196 
      oprot.writeFieldEnd()
16197 
    oprot.writeFieldStop()
16198 
    oprot.writeStructEnd()
16199 
 
16200 
  def validate(self):
16201 
    return
16202 
 
16203 
 
16204 
  def __repr__(self):
16205 
    L = ['%s=%r' % (key, value)
16206 
      for key, value in self.__dict__.iteritems()]
16207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16208 
 
16209 
  def __eq__(self, other):
16210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16211 
 
16212 
  def __ne__(self, other):
16213 
    return not (self == other)
16214 
 
16215 
class markOrderDoaRequestAuthorized_result:
16216 
  """
16217 
  Attributes:
16218 
   - success
16219 
   - ex
16220 
  """
16221 
 
16222 
  thrift_spec = (
16223 
    (0, TType.BOOL, 'success', None, None, ), # 0
16224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16225 
  )
16226 
 
16227 
  def __init__(self, success=None, ex=None,):
16228 
    self.success = success
16229 
    self.ex = ex
16230 
 
16231 
  def read(self, iprot):
16232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16234 
      return
16235 
    iprot.readStructBegin()
16236 
    while True:
16237 
      (fname, ftype, fid) = iprot.readFieldBegin()
16238 
      if ftype == TType.STOP:
16239 
        break
16240 
      if fid == 0:
16241 
        if ftype == TType.BOOL:
16242 
          self.success = iprot.readBool();
16243 
        else:
16244 
          iprot.skip(ftype)
16245 
      elif fid == 1:
16246 
        if ftype == TType.STRUCT:
16247 
          self.ex = TransactionServiceException()
16248 
          self.ex.read(iprot)
16249 
        else:
16250 
          iprot.skip(ftype)
16251 
      else:
16252 
        iprot.skip(ftype)
16253 
      iprot.readFieldEnd()
16254 
    iprot.readStructEnd()
16255 
 
16256 
  def write(self, oprot):
16257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16259 
      return
16260 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16261 
    if self.success is not None:
16262 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16263 
      oprot.writeBool(self.success)
16264 
      oprot.writeFieldEnd()
16265 
    if self.ex is not None:
16266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16267 
      self.ex.write(oprot)
16268 
      oprot.writeFieldEnd()
16269 
    oprot.writeFieldStop()
16270 
    oprot.writeStructEnd()
16271 
 
16272 
  def validate(self):
16273 
    return
16274 
 
16275 
 
16276 
  def __repr__(self):
16277 
    L = ['%s=%r' % (key, value)
16278 
      for key, value in self.__dict__.iteritems()]
16279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16280 
 
16281 
  def __eq__(self, other):
16282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16283 
 
16284 
  def __ne__(self, other):
16285 
    return not (self == other)
16286 
 
4488 rajveer 16287 
class markOrderReturnRequestReceived_args:
16288 
  """
16289 
  Attributes:
16290 
   - orderId
16291 
  """
16292 
 
16293 
  thrift_spec = (
16294 
    None, # 0
16295 
    (1, TType.I64, 'orderId', None, None, ), # 1
16296 
  )
16297 
 
16298 
  def __init__(self, orderId=None,):
16299 
    self.orderId = orderId
16300 
 
16301 
  def read(self, iprot):
16302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16304 
      return
16305 
    iprot.readStructBegin()
16306 
    while True:
16307 
      (fname, ftype, fid) = iprot.readFieldBegin()
16308 
      if ftype == TType.STOP:
16309 
        break
16310 
      if fid == 1:
16311 
        if ftype == TType.I64:
16312 
          self.orderId = iprot.readI64();
16313 
        else:
16314 
          iprot.skip(ftype)
16315 
      else:
16316 
        iprot.skip(ftype)
16317 
      iprot.readFieldEnd()
16318 
    iprot.readStructEnd()
16319 
 
16320 
  def write(self, oprot):
16321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16323 
      return
16324 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16325 
    if self.orderId is not None:
16326 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16327 
      oprot.writeI64(self.orderId)
16328 
      oprot.writeFieldEnd()
16329 
    oprot.writeFieldStop()
16330 
    oprot.writeStructEnd()
16331 
 
16332 
  def validate(self):
16333 
    return
16334 
 
16335 
 
16336 
  def __repr__(self):
16337 
    L = ['%s=%r' % (key, value)
16338 
      for key, value in self.__dict__.iteritems()]
16339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16340 
 
16341 
  def __eq__(self, other):
16342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16343 
 
16344 
  def __ne__(self, other):
16345 
    return not (self == other)
16346 
 
16347 
class markOrderReturnRequestReceived_result:
16348 
  """
16349 
  Attributes:
16350 
   - success
16351 
   - ex
16352 
  """
16353 
 
16354 
  thrift_spec = (
16355 
    (0, TType.BOOL, 'success', None, None, ), # 0
16356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16357 
  )
16358 
 
16359 
  def __init__(self, success=None, ex=None,):
16360 
    self.success = success
16361 
    self.ex = ex
16362 
 
16363 
  def read(self, iprot):
16364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16366 
      return
16367 
    iprot.readStructBegin()
16368 
    while True:
16369 
      (fname, ftype, fid) = iprot.readFieldBegin()
16370 
      if ftype == TType.STOP:
16371 
        break
16372 
      if fid == 0:
16373 
        if ftype == TType.BOOL:
16374 
          self.success = iprot.readBool();
16375 
        else:
16376 
          iprot.skip(ftype)
16377 
      elif fid == 1:
16378 
        if ftype == TType.STRUCT:
16379 
          self.ex = TransactionServiceException()
16380 
          self.ex.read(iprot)
16381 
        else:
16382 
          iprot.skip(ftype)
16383 
      else:
16384 
        iprot.skip(ftype)
16385 
      iprot.readFieldEnd()
16386 
    iprot.readStructEnd()
16387 
 
16388 
  def write(self, oprot):
16389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16391 
      return
16392 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16393 
    if self.success is not None:
16394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16395 
      oprot.writeBool(self.success)
16396 
      oprot.writeFieldEnd()
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 
 
16419 
class markOrderReturnRequestAuthorized_args:
16420 
  """
16421 
  Attributes:
16422 
   - orderId
16423 
   - isAuthorized
16424 
  """
16425 
 
16426 
  thrift_spec = (
16427 
    None, # 0
16428 
    (1, TType.I64, 'orderId', None, None, ), # 1
16429 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16430 
  )
16431 
 
16432 
  def __init__(self, orderId=None, isAuthorized=None,):
16433 
    self.orderId = orderId
16434 
    self.isAuthorized = isAuthorized
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.BOOL:
16452 
          self.isAuthorized = iprot.readBool();
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('markOrderReturnRequestAuthorized_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.isAuthorized is not None:
16470 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16471 
      oprot.writeBool(self.isAuthorized)
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 markOrderReturnRequestAuthorized_result:
16492 
  """
16493 
  Attributes:
16494 
   - success
16495 
   - ex
16496 
  """
16497 
 
16498 
  thrift_spec = (
16499 
    (0, TType.BOOL, 'success', None, None, ), # 0
16500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16501 
  )
16502 
 
16503 
  def __init__(self, success=None, ex=None,):
16504 
    self.success = success
16505 
    self.ex = ex
16506 
 
16507 
  def read(self, iprot):
16508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16510 
      return
16511 
    iprot.readStructBegin()
16512 
    while True:
16513 
      (fname, ftype, fid) = iprot.readFieldBegin()
16514 
      if ftype == TType.STOP:
16515 
        break
16516 
      if fid == 0:
16517 
        if ftype == TType.BOOL:
16518 
          self.success = iprot.readBool();
16519 
        else:
16520 
          iprot.skip(ftype)
16521 
      elif fid == 1:
16522 
        if ftype == TType.STRUCT:
16523 
          self.ex = TransactionServiceException()
16524 
          self.ex.read(iprot)
16525 
        else:
16526 
          iprot.skip(ftype)
16527 
      else:
16528 
        iprot.skip(ftype)
16529 
      iprot.readFieldEnd()
16530 
    iprot.readStructEnd()
16531 
 
16532 
  def write(self, oprot):
16533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16535 
      return
16536 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16537 
    if self.success is not None:
16538 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16539 
      oprot.writeBool(self.success)
16540 
      oprot.writeFieldEnd()
16541 
    if self.ex is not None:
16542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16543 
      self.ex.write(oprot)
16544 
      oprot.writeFieldEnd()
16545 
    oprot.writeFieldStop()
16546 
    oprot.writeStructEnd()
16547 
 
16548 
  def validate(self):
16549 
    return
16550 
 
16551 
 
16552 
  def __repr__(self):
16553 
    L = ['%s=%r' % (key, value)
16554 
      for key, value in self.__dict__.iteritems()]
16555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16556 
 
16557 
  def __eq__(self, other):
16558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16559 
 
16560 
  def __ne__(self, other):
16561 
    return not (self == other)
16562 
 
2536 chandransh 16563 
class requestPickupNumber_args:
16564 
  """
16565 
  Attributes:
16566 
   - orderId
4579 rajveer 16567 
   - providerId
2536 chandransh 16568 
  """
16569 
 
16570 
  thrift_spec = (
16571 
    None, # 0
16572 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16573 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16574 
  )
16575 
 
4579 rajveer 16576 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16577 
    self.orderId = orderId
4579 rajveer 16578 
    self.providerId = providerId
2536 chandransh 16579 
 
16580 
  def read(self, iprot):
16581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16583 
      return
16584 
    iprot.readStructBegin()
16585 
    while True:
16586 
      (fname, ftype, fid) = iprot.readFieldBegin()
16587 
      if ftype == TType.STOP:
16588 
        break
16589 
      if fid == 1:
16590 
        if ftype == TType.I64:
16591 
          self.orderId = iprot.readI64();
16592 
        else:
16593 
          iprot.skip(ftype)
4579 rajveer 16594 
      elif fid == 2:
16595 
        if ftype == TType.I64:
16596 
          self.providerId = iprot.readI64();
16597 
        else:
16598 
          iprot.skip(ftype)
2536 chandransh 16599 
      else:
16600 
        iprot.skip(ftype)
16601 
      iprot.readFieldEnd()
16602 
    iprot.readStructEnd()
16603 
 
16604 
  def write(self, oprot):
16605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16607 
      return
16608 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16609 
    if self.orderId is not None:
2536 chandransh 16610 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16611 
      oprot.writeI64(self.orderId)
16612 
      oprot.writeFieldEnd()
4579 rajveer 16613 
    if self.providerId is not None:
16614 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16615 
      oprot.writeI64(self.providerId)
16616 
      oprot.writeFieldEnd()
2536 chandransh 16617 
    oprot.writeFieldStop()
16618 
    oprot.writeStructEnd()
16619 
 
3431 rajveer 16620 
  def validate(self):
16621 
    return
16622 
 
16623 
 
2536 chandransh 16624 
  def __repr__(self):
16625 
    L = ['%s=%r' % (key, value)
16626 
      for key, value in self.__dict__.iteritems()]
16627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16628 
 
16629 
  def __eq__(self, other):
16630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16631 
 
16632 
  def __ne__(self, other):
16633 
    return not (self == other)
16634 
 
16635 
class requestPickupNumber_result:
16636 
  """
16637 
  Attributes:
16638 
   - success
16639 
   - ex
16640 
  """
16641 
 
16642 
  thrift_spec = (
16643 
    (0, TType.BOOL, 'success', None, None, ), # 0
16644 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16645 
  )
16646 
 
16647 
  def __init__(self, success=None, ex=None,):
16648 
    self.success = success
16649 
    self.ex = ex
16650 
 
16651 
  def read(self, iprot):
16652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16654 
      return
16655 
    iprot.readStructBegin()
16656 
    while True:
16657 
      (fname, ftype, fid) = iprot.readFieldBegin()
16658 
      if ftype == TType.STOP:
16659 
        break
16660 
      if fid == 0:
16661 
        if ftype == TType.BOOL:
16662 
          self.success = iprot.readBool();
16663 
        else:
16664 
          iprot.skip(ftype)
16665 
      elif fid == 1:
16666 
        if ftype == TType.STRUCT:
16667 
          self.ex = TransactionServiceException()
16668 
          self.ex.read(iprot)
16669 
        else:
16670 
          iprot.skip(ftype)
16671 
      else:
16672 
        iprot.skip(ftype)
16673 
      iprot.readFieldEnd()
16674 
    iprot.readStructEnd()
16675 
 
16676 
  def write(self, oprot):
16677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16679 
      return
16680 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16681 
    if self.success is not None:
2536 chandransh 16682 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16683 
      oprot.writeBool(self.success)
16684 
      oprot.writeFieldEnd()
3431 rajveer 16685 
    if self.ex is not None:
2536 chandransh 16686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16687 
      self.ex.write(oprot)
16688 
      oprot.writeFieldEnd()
16689 
    oprot.writeFieldStop()
16690 
    oprot.writeStructEnd()
16691 
 
3431 rajveer 16692 
  def validate(self):
16693 
    return
16694 
 
16695 
 
2536 chandransh 16696 
  def __repr__(self):
16697 
    L = ['%s=%r' % (key, value)
16698 
      for key, value in self.__dict__.iteritems()]
16699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16700 
 
16701 
  def __eq__(self, other):
16702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16703 
 
16704 
  def __ne__(self, other):
16705 
    return not (self == other)
16706 
 
16707 
class authorizePickup_args:
16708 
  """
16709 
  Attributes:
16710 
   - orderId
16711 
   - pickupNumber
4602 rajveer 16712 
   - providerId
2536 chandransh 16713 
  """
16714 
 
16715 
  thrift_spec = (
16716 
    None, # 0
16717 
    (1, TType.I64, 'orderId', None, None, ), # 1
16718 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16719 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16720 
  )
16721 
 
4602 rajveer 16722 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16723 
    self.orderId = orderId
16724 
    self.pickupNumber = pickupNumber
4602 rajveer 16725 
    self.providerId = providerId
2536 chandransh 16726 
 
16727 
  def read(self, iprot):
16728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16730 
      return
16731 
    iprot.readStructBegin()
16732 
    while True:
16733 
      (fname, ftype, fid) = iprot.readFieldBegin()
16734 
      if ftype == TType.STOP:
16735 
        break
16736 
      if fid == 1:
16737 
        if ftype == TType.I64:
16738 
          self.orderId = iprot.readI64();
16739 
        else:
16740 
          iprot.skip(ftype)
16741 
      elif fid == 2:
16742 
        if ftype == TType.STRING:
16743 
          self.pickupNumber = iprot.readString();
16744 
        else:
16745 
          iprot.skip(ftype)
4602 rajveer 16746 
      elif fid == 3:
16747 
        if ftype == TType.I64:
16748 
          self.providerId = iprot.readI64();
16749 
        else:
16750 
          iprot.skip(ftype)
2536 chandransh 16751 
      else:
16752 
        iprot.skip(ftype)
16753 
      iprot.readFieldEnd()
16754 
    iprot.readStructEnd()
16755 
 
16756 
  def write(self, oprot):
16757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16759 
      return
16760 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 16761 
    if self.orderId is not None:
2536 chandransh 16762 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16763 
      oprot.writeI64(self.orderId)
16764 
      oprot.writeFieldEnd()
3431 rajveer 16765 
    if self.pickupNumber is not None:
2536 chandransh 16766 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
16767 
      oprot.writeString(self.pickupNumber)
16768 
      oprot.writeFieldEnd()
4602 rajveer 16769 
    if self.providerId is not None:
16770 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
16771 
      oprot.writeI64(self.providerId)
16772 
      oprot.writeFieldEnd()
2536 chandransh 16773 
    oprot.writeFieldStop()
16774 
    oprot.writeStructEnd()
16775 
 
3431 rajveer 16776 
  def validate(self):
16777 
    return
16778 
 
16779 
 
2536 chandransh 16780 
  def __repr__(self):
16781 
    L = ['%s=%r' % (key, value)
16782 
      for key, value in self.__dict__.iteritems()]
16783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16784 
 
16785 
  def __eq__(self, other):
16786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16787 
 
16788 
  def __ne__(self, other):
16789 
    return not (self == other)
16790 
 
16791 
class authorizePickup_result:
16792 
  """
16793 
  Attributes:
16794 
   - success
16795 
   - ex
16796 
  """
16797 
 
16798 
  thrift_spec = (
16799 
    (0, TType.BOOL, 'success', None, None, ), # 0
16800 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16801 
  )
16802 
 
16803 
  def __init__(self, success=None, ex=None,):
16804 
    self.success = success
16805 
    self.ex = ex
16806 
 
16807 
  def read(self, iprot):
16808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16810 
      return
16811 
    iprot.readStructBegin()
16812 
    while True:
16813 
      (fname, ftype, fid) = iprot.readFieldBegin()
16814 
      if ftype == TType.STOP:
16815 
        break
16816 
      if fid == 0:
16817 
        if ftype == TType.BOOL:
16818 
          self.success = iprot.readBool();
16819 
        else:
16820 
          iprot.skip(ftype)
16821 
      elif fid == 1:
16822 
        if ftype == TType.STRUCT:
16823 
          self.ex = TransactionServiceException()
16824 
          self.ex.read(iprot)
16825 
        else:
16826 
          iprot.skip(ftype)
16827 
      else:
16828 
        iprot.skip(ftype)
16829 
      iprot.readFieldEnd()
16830 
    iprot.readStructEnd()
16831 
 
16832 
  def write(self, oprot):
16833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16835 
      return
16836 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 16837 
    if self.success is not None:
2536 chandransh 16838 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16839 
      oprot.writeBool(self.success)
16840 
      oprot.writeFieldEnd()
3431 rajveer 16841 
    if self.ex is not None:
2536 chandransh 16842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16843 
      self.ex.write(oprot)
16844 
      oprot.writeFieldEnd()
16845 
    oprot.writeFieldStop()
16846 
    oprot.writeStructEnd()
16847 
 
3431 rajveer 16848 
  def validate(self):
16849 
    return
16850 
 
16851 
 
2536 chandransh 16852 
  def __repr__(self):
16853 
    L = ['%s=%r' % (key, value)
16854 
      for key, value in self.__dict__.iteritems()]
16855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16856 
 
16857 
  def __eq__(self, other):
16858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16859 
 
16860 
  def __ne__(self, other):
16861 
    return not (self == other)
16862 
 
2764 chandransh 16863 
class markDoasAsPickedUp_args:
16864 
  """
16865 
  Attributes:
16866 
   - providerId
16867 
   - pickupDetails
16868 
  """
16869 
 
16870 
  thrift_spec = (
16871 
    None, # 0
16872 
    (1, TType.I64, 'providerId', None, None, ), # 1
16873 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
16874 
  )
16875 
 
16876 
  def __init__(self, providerId=None, pickupDetails=None,):
16877 
    self.providerId = providerId
16878 
    self.pickupDetails = pickupDetails
16879 
 
16880 
  def read(self, iprot):
16881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16883 
      return
16884 
    iprot.readStructBegin()
16885 
    while True:
16886 
      (fname, ftype, fid) = iprot.readFieldBegin()
16887 
      if ftype == TType.STOP:
16888 
        break
16889 
      if fid == 1:
16890 
        if ftype == TType.I64:
16891 
          self.providerId = iprot.readI64();
16892 
        else:
16893 
          iprot.skip(ftype)
16894 
      elif fid == 2:
16895 
        if ftype == TType.MAP:
16896 
          self.pickupDetails = {}
6031 rajveer 16897 
          (_ktype365, _vtype366, _size364 ) = iprot.readMapBegin()
16898 
          for _i368 in xrange(_size364):
16899 
            _key369 = iprot.readString();
16900 
            _val370 = iprot.readString();
16901 
            self.pickupDetails[_key369] = _val370
2764 chandransh 16902 
          iprot.readMapEnd()
16903 
        else:
16904 
          iprot.skip(ftype)
16905 
      else:
16906 
        iprot.skip(ftype)
16907 
      iprot.readFieldEnd()
16908 
    iprot.readStructEnd()
16909 
 
16910 
  def write(self, oprot):
16911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16913 
      return
16914 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 16915 
    if self.providerId is not None:
2764 chandransh 16916 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16917 
      oprot.writeI64(self.providerId)
16918 
      oprot.writeFieldEnd()
3431 rajveer 16919 
    if self.pickupDetails is not None:
2764 chandransh 16920 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
16921 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 16922 
      for kiter371,viter372 in self.pickupDetails.items():
16923 
        oprot.writeString(kiter371)
16924 
        oprot.writeString(viter372)
2764 chandransh 16925 
      oprot.writeMapEnd()
16926 
      oprot.writeFieldEnd()
16927 
    oprot.writeFieldStop()
16928 
    oprot.writeStructEnd()
16929 
 
3431 rajveer 16930 
  def validate(self):
16931 
    return
16932 
 
16933 
 
2764 chandransh 16934 
  def __repr__(self):
16935 
    L = ['%s=%r' % (key, value)
16936 
      for key, value in self.__dict__.iteritems()]
16937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16938 
 
16939 
  def __eq__(self, other):
16940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16941 
 
16942 
  def __ne__(self, other):
16943 
    return not (self == other)
16944 
 
16945 
class markDoasAsPickedUp_result:
4910 phani.kuma 16946 
 
16947 
  thrift_spec = (
16948 
  )
16949 
 
16950 
  def read(self, iprot):
16951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16953 
      return
16954 
    iprot.readStructBegin()
16955 
    while True:
16956 
      (fname, ftype, fid) = iprot.readFieldBegin()
16957 
      if ftype == TType.STOP:
16958 
        break
16959 
      else:
16960 
        iprot.skip(ftype)
16961 
      iprot.readFieldEnd()
16962 
    iprot.readStructEnd()
16963 
 
16964 
  def write(self, oprot):
16965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16967 
      return
16968 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
16969 
    oprot.writeFieldStop()
16970 
    oprot.writeStructEnd()
16971 
 
16972 
  def validate(self):
16973 
    return
16974 
 
16975 
 
16976 
  def __repr__(self):
16977 
    L = ['%s=%r' % (key, value)
16978 
      for key, value in self.__dict__.iteritems()]
16979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16980 
 
16981 
  def __eq__(self, other):
16982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16983 
 
16984 
  def __ne__(self, other):
16985 
    return not (self == other)
16986 
 
16987 
class getDoasNotPickedUp_args:
2764 chandransh 16988 
  """
16989 
  Attributes:
4910 phani.kuma 16990 
   - providerId
16991 
  """
16992 
 
16993 
  thrift_spec = (
16994 
    None, # 0
16995 
    (1, TType.I64, 'providerId', None, None, ), # 1
16996 
  )
16997 
 
16998 
  def __init__(self, providerId=None,):
16999 
    self.providerId = providerId
17000 
 
17001 
  def read(self, iprot):
17002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17004 
      return
17005 
    iprot.readStructBegin()
17006 
    while True:
17007 
      (fname, ftype, fid) = iprot.readFieldBegin()
17008 
      if ftype == TType.STOP:
17009 
        break
17010 
      if fid == 1:
17011 
        if ftype == TType.I64:
17012 
          self.providerId = iprot.readI64();
17013 
        else:
17014 
          iprot.skip(ftype)
17015 
      else:
17016 
        iprot.skip(ftype)
17017 
      iprot.readFieldEnd()
17018 
    iprot.readStructEnd()
17019 
 
17020 
  def write(self, oprot):
17021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17023 
      return
17024 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17025 
    if self.providerId is not None:
17026 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17027 
      oprot.writeI64(self.providerId)
17028 
      oprot.writeFieldEnd()
17029 
    oprot.writeFieldStop()
17030 
    oprot.writeStructEnd()
17031 
 
17032 
  def validate(self):
17033 
    return
17034 
 
17035 
 
17036 
  def __repr__(self):
17037 
    L = ['%s=%r' % (key, value)
17038 
      for key, value in self.__dict__.iteritems()]
17039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17040 
 
17041 
  def __eq__(self, other):
17042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17043 
 
17044 
  def __ne__(self, other):
17045 
    return not (self == other)
17046 
 
17047 
class getDoasNotPickedUp_result:
17048 
  """
17049 
  Attributes:
2764 chandransh 17050 
   - success
17051 
  """
17052 
 
17053 
  thrift_spec = (
17054 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17055 
  )
17056 
 
17057 
  def __init__(self, success=None,):
17058 
    self.success = success
17059 
 
17060 
  def read(self, iprot):
17061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17063 
      return
17064 
    iprot.readStructBegin()
17065 
    while True:
17066 
      (fname, ftype, fid) = iprot.readFieldBegin()
17067 
      if ftype == TType.STOP:
17068 
        break
17069 
      if fid == 0:
17070 
        if ftype == TType.LIST:
17071 
          self.success = []
6031 rajveer 17072 
          (_etype376, _size373) = iprot.readListBegin()
17073 
          for _i377 in xrange(_size373):
17074 
            _elem378 = Order()
17075 
            _elem378.read(iprot)
17076 
            self.success.append(_elem378)
2764 chandransh 17077 
          iprot.readListEnd()
17078 
        else:
17079 
          iprot.skip(ftype)
17080 
      else:
17081 
        iprot.skip(ftype)
17082 
      iprot.readFieldEnd()
17083 
    iprot.readStructEnd()
17084 
 
17085 
  def write(self, oprot):
17086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17088 
      return
4910 phani.kuma 17089 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17090 
    if self.success is not None:
2764 chandransh 17091 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17092 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17093 
      for iter379 in self.success:
17094 
        iter379.write(oprot)
2764 chandransh 17095 
      oprot.writeListEnd()
17096 
      oprot.writeFieldEnd()
17097 
    oprot.writeFieldStop()
17098 
    oprot.writeStructEnd()
17099 
 
3431 rajveer 17100 
  def validate(self):
17101 
    return
17102 
 
17103 
 
2764 chandransh 17104 
  def __repr__(self):
17105 
    L = ['%s=%r' % (key, value)
17106 
      for key, value in self.__dict__.iteritems()]
17107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17108 
 
17109 
  def __eq__(self, other):
17110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17111 
 
17112 
  def __ne__(self, other):
17113 
    return not (self == other)
17114 
 
4741 phani.kuma 17115 
class markReturnOrdersAsPickedUp_args:
17116 
  """
17117 
  Attributes:
17118 
   - providerId
17119 
   - pickupDetails
17120 
  """
17121 
 
17122 
  thrift_spec = (
17123 
    None, # 0
17124 
    (1, TType.I64, 'providerId', None, None, ), # 1
17125 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17126 
  )
17127 
 
17128 
  def __init__(self, providerId=None, pickupDetails=None,):
17129 
    self.providerId = providerId
17130 
    self.pickupDetails = pickupDetails
17131 
 
17132 
  def read(self, iprot):
17133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17135 
      return
17136 
    iprot.readStructBegin()
17137 
    while True:
17138 
      (fname, ftype, fid) = iprot.readFieldBegin()
17139 
      if ftype == TType.STOP:
17140 
        break
17141 
      if fid == 1:
17142 
        if ftype == TType.I64:
17143 
          self.providerId = iprot.readI64();
17144 
        else:
17145 
          iprot.skip(ftype)
17146 
      elif fid == 2:
17147 
        if ftype == TType.MAP:
17148 
          self.pickupDetails = {}
6031 rajveer 17149 
          (_ktype381, _vtype382, _size380 ) = iprot.readMapBegin()
17150 
          for _i384 in xrange(_size380):
17151 
            _key385 = iprot.readString();
17152 
            _val386 = iprot.readString();
17153 
            self.pickupDetails[_key385] = _val386
4741 phani.kuma 17154 
          iprot.readMapEnd()
17155 
        else:
17156 
          iprot.skip(ftype)
17157 
      else:
17158 
        iprot.skip(ftype)
17159 
      iprot.readFieldEnd()
17160 
    iprot.readStructEnd()
17161 
 
17162 
  def write(self, oprot):
17163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17165 
      return
17166 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17167 
    if self.providerId is not None:
17168 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17169 
      oprot.writeI64(self.providerId)
17170 
      oprot.writeFieldEnd()
17171 
    if self.pickupDetails is not None:
17172 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17173 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6031 rajveer 17174 
      for kiter387,viter388 in self.pickupDetails.items():
17175 
        oprot.writeString(kiter387)
17176 
        oprot.writeString(viter388)
4741 phani.kuma 17177 
      oprot.writeMapEnd()
17178 
      oprot.writeFieldEnd()
17179 
    oprot.writeFieldStop()
17180 
    oprot.writeStructEnd()
17181 
 
17182 
  def validate(self):
17183 
    return
17184 
 
17185 
 
17186 
  def __repr__(self):
17187 
    L = ['%s=%r' % (key, value)
17188 
      for key, value in self.__dict__.iteritems()]
17189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17190 
 
17191 
  def __eq__(self, other):
17192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17193 
 
17194 
  def __ne__(self, other):
17195 
    return not (self == other)
17196 
 
17197 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17198 
 
17199 
  thrift_spec = (
17200 
  )
17201 
 
17202 
  def read(self, iprot):
17203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17205 
      return
17206 
    iprot.readStructBegin()
17207 
    while True:
17208 
      (fname, ftype, fid) = iprot.readFieldBegin()
17209 
      if ftype == TType.STOP:
17210 
        break
17211 
      else:
17212 
        iprot.skip(ftype)
17213 
      iprot.readFieldEnd()
17214 
    iprot.readStructEnd()
17215 
 
17216 
  def write(self, oprot):
17217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17219 
      return
17220 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17221 
    oprot.writeFieldStop()
17222 
    oprot.writeStructEnd()
17223 
 
17224 
  def validate(self):
17225 
    return
17226 
 
17227 
 
17228 
  def __repr__(self):
17229 
    L = ['%s=%r' % (key, value)
17230 
      for key, value in self.__dict__.iteritems()]
17231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17232 
 
17233 
  def __eq__(self, other):
17234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17235 
 
17236 
  def __ne__(self, other):
17237 
    return not (self == other)
17238 
 
17239 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17240 
  """
17241 
  Attributes:
4910 phani.kuma 17242 
   - providerId
17243 
  """
17244 
 
17245 
  thrift_spec = (
17246 
    None, # 0
17247 
    (1, TType.I64, 'providerId', None, None, ), # 1
17248 
  )
17249 
 
17250 
  def __init__(self, providerId=None,):
17251 
    self.providerId = providerId
17252 
 
17253 
  def read(self, iprot):
17254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17256 
      return
17257 
    iprot.readStructBegin()
17258 
    while True:
17259 
      (fname, ftype, fid) = iprot.readFieldBegin()
17260 
      if ftype == TType.STOP:
17261 
        break
17262 
      if fid == 1:
17263 
        if ftype == TType.I64:
17264 
          self.providerId = iprot.readI64();
17265 
        else:
17266 
          iprot.skip(ftype)
17267 
      else:
17268 
        iprot.skip(ftype)
17269 
      iprot.readFieldEnd()
17270 
    iprot.readStructEnd()
17271 
 
17272 
  def write(self, oprot):
17273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17275 
      return
17276 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17277 
    if self.providerId is not None:
17278 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17279 
      oprot.writeI64(self.providerId)
17280 
      oprot.writeFieldEnd()
17281 
    oprot.writeFieldStop()
17282 
    oprot.writeStructEnd()
17283 
 
17284 
  def validate(self):
17285 
    return
17286 
 
17287 
 
17288 
  def __repr__(self):
17289 
    L = ['%s=%r' % (key, value)
17290 
      for key, value in self.__dict__.iteritems()]
17291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17292 
 
17293 
  def __eq__(self, other):
17294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17295 
 
17296 
  def __ne__(self, other):
17297 
    return not (self == other)
17298 
 
17299 
class getReturnOrdersNotPickedUp_result:
17300 
  """
17301 
  Attributes:
4741 phani.kuma 17302 
   - success
17303 
  """
17304 
 
17305 
  thrift_spec = (
17306 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17307 
  )
17308 
 
17309 
  def __init__(self, success=None,):
17310 
    self.success = success
17311 
 
17312 
  def read(self, iprot):
17313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17315 
      return
17316 
    iprot.readStructBegin()
17317 
    while True:
17318 
      (fname, ftype, fid) = iprot.readFieldBegin()
17319 
      if ftype == TType.STOP:
17320 
        break
17321 
      if fid == 0:
17322 
        if ftype == TType.LIST:
17323 
          self.success = []
6031 rajveer 17324 
          (_etype392, _size389) = iprot.readListBegin()
17325 
          for _i393 in xrange(_size389):
17326 
            _elem394 = Order()
17327 
            _elem394.read(iprot)
17328 
            self.success.append(_elem394)
4741 phani.kuma 17329 
          iprot.readListEnd()
17330 
        else:
17331 
          iprot.skip(ftype)
17332 
      else:
17333 
        iprot.skip(ftype)
17334 
      iprot.readFieldEnd()
17335 
    iprot.readStructEnd()
17336 
 
17337 
  def write(self, oprot):
17338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17340 
      return
4910 phani.kuma 17341 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17342 
    if self.success is not None:
17343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 17345 
      for iter395 in self.success:
17346 
        iter395.write(oprot)
4741 phani.kuma 17347 
      oprot.writeListEnd()
17348 
      oprot.writeFieldEnd()
17349 
    oprot.writeFieldStop()
17350 
    oprot.writeStructEnd()
17351 
 
17352 
  def validate(self):
17353 
    return
17354 
 
17355 
 
17356 
  def __repr__(self):
17357 
    L = ['%s=%r' % (key, value)
17358 
      for key, value in self.__dict__.iteritems()]
17359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17360 
 
17361 
  def __eq__(self, other):
17362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17363 
 
17364 
  def __ne__(self, other):
17365 
    return not (self == other)
17366 
 
2616 chandransh 17367 
class receiveReturn_args:
2591 chandransh 17368 
  """
17369 
  Attributes:
17370 
   - orderId
4479 rajveer 17371 
   - receiveCondition
2591 chandransh 17372 
  """
2536 chandransh 17373 
 
2591 chandransh 17374 
  thrift_spec = (
17375 
    None, # 0
17376 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17377 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17378 
  )
17379 
 
4479 rajveer 17380 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17381 
    self.orderId = orderId
4479 rajveer 17382 
    self.receiveCondition = receiveCondition
2591 chandransh 17383 
 
17384 
  def read(self, iprot):
17385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17387 
      return
17388 
    iprot.readStructBegin()
17389 
    while True:
17390 
      (fname, ftype, fid) = iprot.readFieldBegin()
17391 
      if ftype == TType.STOP:
17392 
        break
17393 
      if fid == 1:
17394 
        if ftype == TType.I64:
17395 
          self.orderId = iprot.readI64();
17396 
        else:
17397 
          iprot.skip(ftype)
4479 rajveer 17398 
      elif fid == 2:
17399 
        if ftype == TType.I64:
17400 
          self.receiveCondition = iprot.readI64();
17401 
        else:
17402 
          iprot.skip(ftype)
2591 chandransh 17403 
      else:
17404 
        iprot.skip(ftype)
17405 
      iprot.readFieldEnd()
17406 
    iprot.readStructEnd()
17407 
 
17408 
  def write(self, oprot):
17409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17411 
      return
2616 chandransh 17412 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17413 
    if self.orderId is not None:
2591 chandransh 17414 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17415 
      oprot.writeI64(self.orderId)
17416 
      oprot.writeFieldEnd()
4479 rajveer 17417 
    if self.receiveCondition is not None:
17418 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17419 
      oprot.writeI64(self.receiveCondition)
17420 
      oprot.writeFieldEnd()
2591 chandransh 17421 
    oprot.writeFieldStop()
17422 
    oprot.writeStructEnd()
17423 
 
3431 rajveer 17424 
  def validate(self):
17425 
    return
17426 
 
17427 
 
2591 chandransh 17428 
  def __repr__(self):
17429 
    L = ['%s=%r' % (key, value)
17430 
      for key, value in self.__dict__.iteritems()]
17431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17432 
 
17433 
  def __eq__(self, other):
17434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17435 
 
17436 
  def __ne__(self, other):
17437 
    return not (self == other)
17438 
 
2616 chandransh 17439 
class receiveReturn_result:
2591 chandransh 17440 
  """
17441 
  Attributes:
17442 
   - success
17443 
   - ex
17444 
  """
17445 
 
17446 
  thrift_spec = (
17447 
    (0, TType.BOOL, 'success', None, None, ), # 0
17448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17449 
  )
17450 
 
17451 
  def __init__(self, success=None, ex=None,):
17452 
    self.success = success
17453 
    self.ex = ex
17454 
 
17455 
  def read(self, iprot):
17456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17458 
      return
17459 
    iprot.readStructBegin()
17460 
    while True:
17461 
      (fname, ftype, fid) = iprot.readFieldBegin()
17462 
      if ftype == TType.STOP:
17463 
        break
17464 
      if fid == 0:
17465 
        if ftype == TType.BOOL:
17466 
          self.success = iprot.readBool();
17467 
        else:
17468 
          iprot.skip(ftype)
17469 
      elif fid == 1:
17470 
        if ftype == TType.STRUCT:
17471 
          self.ex = TransactionServiceException()
17472 
          self.ex.read(iprot)
17473 
        else:
17474 
          iprot.skip(ftype)
17475 
      else:
17476 
        iprot.skip(ftype)
17477 
      iprot.readFieldEnd()
17478 
    iprot.readStructEnd()
17479 
 
17480 
  def write(self, oprot):
17481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17483 
      return
2616 chandransh 17484 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17485 
    if self.success is not None:
2591 chandransh 17486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17487 
      oprot.writeBool(self.success)
17488 
      oprot.writeFieldEnd()
3431 rajveer 17489 
    if self.ex is not None:
2591 chandransh 17490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17491 
      self.ex.write(oprot)
17492 
      oprot.writeFieldEnd()
17493 
    oprot.writeFieldStop()
17494 
    oprot.writeStructEnd()
17495 
 
3431 rajveer 17496 
  def validate(self):
17497 
    return
17498 
 
17499 
 
2591 chandransh 17500 
  def __repr__(self):
17501 
    L = ['%s=%r' % (key, value)
17502 
      for key, value in self.__dict__.iteritems()]
17503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17504 
 
17505 
  def __eq__(self, other):
17506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17507 
 
17508 
  def __ne__(self, other):
17509 
    return not (self == other)
17510 
 
17511 
class validateDoa_args:
17512 
  """
17513 
  Attributes:
17514 
   - orderId
17515 
   - isValid
17516 
  """
17517 
 
17518 
  thrift_spec = (
17519 
    None, # 0
17520 
    (1, TType.I64, 'orderId', None, None, ), # 1
17521 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17522 
  )
17523 
 
17524 
  def __init__(self, orderId=None, isValid=None,):
17525 
    self.orderId = orderId
17526 
    self.isValid = isValid
17527 
 
17528 
  def read(self, iprot):
17529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17531 
      return
17532 
    iprot.readStructBegin()
17533 
    while True:
17534 
      (fname, ftype, fid) = iprot.readFieldBegin()
17535 
      if ftype == TType.STOP:
17536 
        break
17537 
      if fid == 1:
17538 
        if ftype == TType.I64:
17539 
          self.orderId = iprot.readI64();
17540 
        else:
17541 
          iprot.skip(ftype)
17542 
      elif fid == 2:
17543 
        if ftype == TType.BOOL:
17544 
          self.isValid = iprot.readBool();
17545 
        else:
17546 
          iprot.skip(ftype)
17547 
      else:
17548 
        iprot.skip(ftype)
17549 
      iprot.readFieldEnd()
17550 
    iprot.readStructEnd()
17551 
 
17552 
  def write(self, oprot):
17553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17555 
      return
17556 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17557 
    if self.orderId is not None:
2591 chandransh 17558 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17559 
      oprot.writeI64(self.orderId)
17560 
      oprot.writeFieldEnd()
3431 rajveer 17561 
    if self.isValid is not None:
2591 chandransh 17562 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17563 
      oprot.writeBool(self.isValid)
17564 
      oprot.writeFieldEnd()
17565 
    oprot.writeFieldStop()
17566 
    oprot.writeStructEnd()
17567 
 
3431 rajveer 17568 
  def validate(self):
17569 
    return
17570 
 
17571 
 
2591 chandransh 17572 
  def __repr__(self):
17573 
    L = ['%s=%r' % (key, value)
17574 
      for key, value in self.__dict__.iteritems()]
17575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17576 
 
17577 
  def __eq__(self, other):
17578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17579 
 
17580 
  def __ne__(self, other):
17581 
    return not (self == other)
17582 
 
17583 
class validateDoa_result:
17584 
  """
17585 
  Attributes:
17586 
   - success
17587 
   - ex
17588 
  """
17589 
 
17590 
  thrift_spec = (
17591 
    (0, TType.BOOL, 'success', None, None, ), # 0
17592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17593 
  )
17594 
 
17595 
  def __init__(self, success=None, ex=None,):
17596 
    self.success = success
17597 
    self.ex = ex
17598 
 
17599 
  def read(self, iprot):
17600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17602 
      return
17603 
    iprot.readStructBegin()
17604 
    while True:
17605 
      (fname, ftype, fid) = iprot.readFieldBegin()
17606 
      if ftype == TType.STOP:
17607 
        break
17608 
      if fid == 0:
17609 
        if ftype == TType.BOOL:
17610 
          self.success = iprot.readBool();
17611 
        else:
17612 
          iprot.skip(ftype)
17613 
      elif fid == 1:
17614 
        if ftype == TType.STRUCT:
17615 
          self.ex = TransactionServiceException()
17616 
          self.ex.read(iprot)
17617 
        else:
17618 
          iprot.skip(ftype)
17619 
      else:
17620 
        iprot.skip(ftype)
17621 
      iprot.readFieldEnd()
17622 
    iprot.readStructEnd()
17623 
 
17624 
  def write(self, oprot):
17625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17627 
      return
17628 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17629 
    if self.success is not None:
2591 chandransh 17630 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17631 
      oprot.writeBool(self.success)
17632 
      oprot.writeFieldEnd()
3431 rajveer 17633 
    if self.ex is not None:
2591 chandransh 17634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17635 
      self.ex.write(oprot)
17636 
      oprot.writeFieldEnd()
17637 
    oprot.writeFieldStop()
17638 
    oprot.writeStructEnd()
17639 
 
3431 rajveer 17640 
  def validate(self):
17641 
    return
17642 
 
17643 
 
2591 chandransh 17644 
  def __repr__(self):
17645 
    L = ['%s=%r' % (key, value)
17646 
      for key, value in self.__dict__.iteritems()]
17647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17648 
 
17649 
  def __eq__(self, other):
17650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17651 
 
17652 
  def __ne__(self, other):
17653 
    return not (self == other)
17654 
 
4495 rajveer 17655 
class validateReturnProduct_args:
17656 
  """
17657 
  Attributes:
17658 
   - orderId
17659 
   - isUsable
17660 
  """
17661 
 
17662 
  thrift_spec = (
17663 
    None, # 0
17664 
    (1, TType.I64, 'orderId', None, None, ), # 1
17665 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17666 
  )
17667 
 
17668 
  def __init__(self, orderId=None, isUsable=None,):
17669 
    self.orderId = orderId
17670 
    self.isUsable = isUsable
17671 
 
17672 
  def read(self, iprot):
17673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17675 
      return
17676 
    iprot.readStructBegin()
17677 
    while True:
17678 
      (fname, ftype, fid) = iprot.readFieldBegin()
17679 
      if ftype == TType.STOP:
17680 
        break
17681 
      if fid == 1:
17682 
        if ftype == TType.I64:
17683 
          self.orderId = iprot.readI64();
17684 
        else:
17685 
          iprot.skip(ftype)
17686 
      elif fid == 2:
17687 
        if ftype == TType.BOOL:
17688 
          self.isUsable = iprot.readBool();
17689 
        else:
17690 
          iprot.skip(ftype)
17691 
      else:
17692 
        iprot.skip(ftype)
17693 
      iprot.readFieldEnd()
17694 
    iprot.readStructEnd()
17695 
 
17696 
  def write(self, oprot):
17697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17699 
      return
17700 
    oprot.writeStructBegin('validateReturnProduct_args')
17701 
    if self.orderId is not None:
17702 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17703 
      oprot.writeI64(self.orderId)
17704 
      oprot.writeFieldEnd()
17705 
    if self.isUsable is not None:
17706 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17707 
      oprot.writeBool(self.isUsable)
17708 
      oprot.writeFieldEnd()
17709 
    oprot.writeFieldStop()
17710 
    oprot.writeStructEnd()
17711 
 
17712 
  def validate(self):
17713 
    return
17714 
 
17715 
 
17716 
  def __repr__(self):
17717 
    L = ['%s=%r' % (key, value)
17718 
      for key, value in self.__dict__.iteritems()]
17719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17720 
 
17721 
  def __eq__(self, other):
17722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17723 
 
17724 
  def __ne__(self, other):
17725 
    return not (self == other)
17726 
 
17727 
class validateReturnProduct_result:
17728 
  """
17729 
  Attributes:
17730 
   - success
17731 
   - ex
17732 
  """
17733 
 
17734 
  thrift_spec = (
17735 
    (0, TType.BOOL, 'success', None, None, ), # 0
17736 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17737 
  )
17738 
 
17739 
  def __init__(self, success=None, ex=None,):
17740 
    self.success = success
17741 
    self.ex = ex
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 
      if fid == 0:
17753 
        if ftype == TType.BOOL:
17754 
          self.success = iprot.readBool();
17755 
        else:
17756 
          iprot.skip(ftype)
17757 
      elif fid == 1:
17758 
        if ftype == TType.STRUCT:
17759 
          self.ex = TransactionServiceException()
17760 
          self.ex.read(iprot)
17761 
        else:
17762 
          iprot.skip(ftype)
17763 
      else:
17764 
        iprot.skip(ftype)
17765 
      iprot.readFieldEnd()
17766 
    iprot.readStructEnd()
17767 
 
17768 
  def write(self, oprot):
17769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17771 
      return
17772 
    oprot.writeStructBegin('validateReturnProduct_result')
17773 
    if self.success is not None:
17774 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17775 
      oprot.writeBool(self.success)
17776 
      oprot.writeFieldEnd()
17777 
    if self.ex is not None:
17778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17779 
      self.ex.write(oprot)
17780 
      oprot.writeFieldEnd()
17781 
    oprot.writeFieldStop()
17782 
    oprot.writeStructEnd()
17783 
 
17784 
  def validate(self):
17785 
    return
17786 
 
17787 
 
17788 
  def __repr__(self):
17789 
    L = ['%s=%r' % (key, value)
17790 
      for key, value in self.__dict__.iteritems()]
17791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17792 
 
17793 
  def __eq__(self, other):
17794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17795 
 
17796 
  def __ne__(self, other):
17797 
    return not (self == other)
17798 
 
2616 chandransh 17799 
class reshipOrder_args:
17800 
  """
17801 
  Attributes:
17802 
   - orderId
17803 
  """
2591 chandransh 17804 
 
2616 chandransh 17805 
  thrift_spec = (
17806 
    None, # 0
17807 
    (1, TType.I64, 'orderId', None, None, ), # 1
17808 
  )
17809 
 
17810 
  def __init__(self, orderId=None,):
17811 
    self.orderId = orderId
17812 
 
17813 
  def read(self, iprot):
17814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17816 
      return
17817 
    iprot.readStructBegin()
17818 
    while True:
17819 
      (fname, ftype, fid) = iprot.readFieldBegin()
17820 
      if ftype == TType.STOP:
17821 
        break
17822 
      if fid == 1:
17823 
        if ftype == TType.I64:
17824 
          self.orderId = iprot.readI64();
17825 
        else:
17826 
          iprot.skip(ftype)
17827 
      else:
17828 
        iprot.skip(ftype)
17829 
      iprot.readFieldEnd()
17830 
    iprot.readStructEnd()
17831 
 
17832 
  def write(self, oprot):
17833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17835 
      return
17836 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 17837 
    if self.orderId is not None:
2616 chandransh 17838 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17839 
      oprot.writeI64(self.orderId)
17840 
      oprot.writeFieldEnd()
17841 
    oprot.writeFieldStop()
17842 
    oprot.writeStructEnd()
17843 
 
3431 rajveer 17844 
  def validate(self):
17845 
    return
17846 
 
17847 
 
2616 chandransh 17848 
  def __repr__(self):
17849 
    L = ['%s=%r' % (key, value)
17850 
      for key, value in self.__dict__.iteritems()]
17851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17852 
 
17853 
  def __eq__(self, other):
17854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17855 
 
17856 
  def __ne__(self, other):
17857 
    return not (self == other)
17858 
 
17859 
class reshipOrder_result:
17860 
  """
17861 
  Attributes:
17862 
   - success
17863 
   - ex
17864 
  """
17865 
 
17866 
  thrift_spec = (
17867 
    (0, TType.I64, 'success', None, None, ), # 0
17868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17869 
  )
17870 
 
17871 
  def __init__(self, success=None, ex=None,):
17872 
    self.success = success
17873 
    self.ex = ex
17874 
 
17875 
  def read(self, iprot):
17876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17878 
      return
17879 
    iprot.readStructBegin()
17880 
    while True:
17881 
      (fname, ftype, fid) = iprot.readFieldBegin()
17882 
      if ftype == TType.STOP:
17883 
        break
17884 
      if fid == 0:
17885 
        if ftype == TType.I64:
17886 
          self.success = iprot.readI64();
17887 
        else:
17888 
          iprot.skip(ftype)
17889 
      elif fid == 1:
17890 
        if ftype == TType.STRUCT:
17891 
          self.ex = TransactionServiceException()
17892 
          self.ex.read(iprot)
17893 
        else:
17894 
          iprot.skip(ftype)
17895 
      else:
17896 
        iprot.skip(ftype)
17897 
      iprot.readFieldEnd()
17898 
    iprot.readStructEnd()
17899 
 
17900 
  def write(self, oprot):
17901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17903 
      return
17904 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 17905 
    if self.success is not None:
2616 chandransh 17906 
      oprot.writeFieldBegin('success', TType.I64, 0)
17907 
      oprot.writeI64(self.success)
17908 
      oprot.writeFieldEnd()
3431 rajveer 17909 
    if self.ex is not None:
2616 chandransh 17910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17911 
      self.ex.write(oprot)
17912 
      oprot.writeFieldEnd()
17913 
    oprot.writeFieldStop()
17914 
    oprot.writeStructEnd()
17915 
 
3431 rajveer 17916 
  def validate(self):
17917 
    return
17918 
 
17919 
 
2616 chandransh 17920 
  def __repr__(self):
17921 
    L = ['%s=%r' % (key, value)
17922 
      for key, value in self.__dict__.iteritems()]
17923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17924 
 
17925 
  def __eq__(self, other):
17926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17927 
 
17928 
  def __ne__(self, other):
17929 
    return not (self == other)
17930 
 
17931 
class refundOrder_args:
17932 
  """
17933 
  Attributes:
17934 
   - orderId
3226 chandransh 17935 
   - refundedBy
17936 
   - reason
2616 chandransh 17937 
  """
17938 
 
17939 
  thrift_spec = (
17940 
    None, # 0
17941 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 17942 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
17943 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 17944 
  )
17945 
 
3226 chandransh 17946 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 17947 
    self.orderId = orderId
3226 chandransh 17948 
    self.refundedBy = refundedBy
17949 
    self.reason = reason
2616 chandransh 17950 
 
17951 
  def read(self, iprot):
17952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17954 
      return
17955 
    iprot.readStructBegin()
17956 
    while True:
17957 
      (fname, ftype, fid) = iprot.readFieldBegin()
17958 
      if ftype == TType.STOP:
17959 
        break
17960 
      if fid == 1:
17961 
        if ftype == TType.I64:
17962 
          self.orderId = iprot.readI64();
17963 
        else:
17964 
          iprot.skip(ftype)
3226 chandransh 17965 
      elif fid == 2:
17966 
        if ftype == TType.STRING:
17967 
          self.refundedBy = iprot.readString();
17968 
        else:
17969 
          iprot.skip(ftype)
17970 
      elif fid == 3:
17971 
        if ftype == TType.STRING:
17972 
          self.reason = iprot.readString();
17973 
        else:
17974 
          iprot.skip(ftype)
2616 chandransh 17975 
      else:
17976 
        iprot.skip(ftype)
17977 
      iprot.readFieldEnd()
17978 
    iprot.readStructEnd()
17979 
 
17980 
  def write(self, oprot):
17981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17983 
      return
17984 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 17985 
    if self.orderId is not None:
2616 chandransh 17986 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17987 
      oprot.writeI64(self.orderId)
17988 
      oprot.writeFieldEnd()
3431 rajveer 17989 
    if self.refundedBy is not None:
3226 chandransh 17990 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
17991 
      oprot.writeString(self.refundedBy)
17992 
      oprot.writeFieldEnd()
3431 rajveer 17993 
    if self.reason is not None:
3226 chandransh 17994 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
17995 
      oprot.writeString(self.reason)
17996 
      oprot.writeFieldEnd()
2616 chandransh 17997 
    oprot.writeFieldStop()
17998 
    oprot.writeStructEnd()
17999 
 
3431 rajveer 18000 
  def validate(self):
18001 
    return
18002 
 
18003 
 
2616 chandransh 18004 
  def __repr__(self):
18005 
    L = ['%s=%r' % (key, value)
18006 
      for key, value in self.__dict__.iteritems()]
18007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18008 
 
18009 
  def __eq__(self, other):
18010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18011 
 
18012 
  def __ne__(self, other):
18013 
    return not (self == other)
18014 
 
18015 
class refundOrder_result:
18016 
  """
18017 
  Attributes:
18018 
   - success
18019 
   - ex
18020 
  """
18021 
 
18022 
  thrift_spec = (
18023 
    (0, TType.BOOL, 'success', None, None, ), # 0
18024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18025 
  )
18026 
 
18027 
  def __init__(self, success=None, ex=None,):
18028 
    self.success = success
18029 
    self.ex = ex
18030 
 
18031 
  def read(self, iprot):
18032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18034 
      return
18035 
    iprot.readStructBegin()
18036 
    while True:
18037 
      (fname, ftype, fid) = iprot.readFieldBegin()
18038 
      if ftype == TType.STOP:
18039 
        break
18040 
      if fid == 0:
18041 
        if ftype == TType.BOOL:
18042 
          self.success = iprot.readBool();
18043 
        else:
18044 
          iprot.skip(ftype)
18045 
      elif fid == 1:
18046 
        if ftype == TType.STRUCT:
18047 
          self.ex = TransactionServiceException()
18048 
          self.ex.read(iprot)
18049 
        else:
18050 
          iprot.skip(ftype)
18051 
      else:
18052 
        iprot.skip(ftype)
18053 
      iprot.readFieldEnd()
18054 
    iprot.readStructEnd()
18055 
 
18056 
  def write(self, oprot):
18057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18059 
      return
18060 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18061 
    if self.success is not None:
2616 chandransh 18062 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18063 
      oprot.writeBool(self.success)
18064 
      oprot.writeFieldEnd()
3431 rajveer 18065 
    if self.ex is not None:
2616 chandransh 18066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18067 
      self.ex.write(oprot)
18068 
      oprot.writeFieldEnd()
18069 
    oprot.writeFieldStop()
18070 
    oprot.writeStructEnd()
18071 
 
3431 rajveer 18072 
  def validate(self):
18073 
    return
18074 
 
18075 
 
2616 chandransh 18076 
  def __repr__(self):
18077 
    L = ['%s=%r' % (key, value)
18078 
      for key, value in self.__dict__.iteritems()]
18079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18080 
 
18081 
  def __eq__(self, other):
18082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18083 
 
18084 
  def __ne__(self, other):
18085 
    return not (self == other)
18086 
 
2690 chandransh 18087 
class getReturnOrders_args:
18088 
  """
18089 
  Attributes:
18090 
   - warehouseId
18091 
   - fromDate
18092 
   - toDate
18093 
  """
2616 chandransh 18094 
 
2690 chandransh 18095 
  thrift_spec = (
18096 
    None, # 0
18097 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18098 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18099 
    (3, TType.I64, 'toDate', None, None, ), # 3
18100 
  )
18101 
 
18102 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18103 
    self.warehouseId = warehouseId
18104 
    self.fromDate = fromDate
18105 
    self.toDate = toDate
18106 
 
18107 
  def read(self, iprot):
18108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18110 
      return
18111 
    iprot.readStructBegin()
18112 
    while True:
18113 
      (fname, ftype, fid) = iprot.readFieldBegin()
18114 
      if ftype == TType.STOP:
18115 
        break
18116 
      if fid == 1:
18117 
        if ftype == TType.I64:
18118 
          self.warehouseId = iprot.readI64();
18119 
        else:
18120 
          iprot.skip(ftype)
18121 
      elif fid == 2:
18122 
        if ftype == TType.I64:
18123 
          self.fromDate = iprot.readI64();
18124 
        else:
18125 
          iprot.skip(ftype)
18126 
      elif fid == 3:
18127 
        if ftype == TType.I64:
18128 
          self.toDate = iprot.readI64();
18129 
        else:
18130 
          iprot.skip(ftype)
18131 
      else:
18132 
        iprot.skip(ftype)
18133 
      iprot.readFieldEnd()
18134 
    iprot.readStructEnd()
18135 
 
18136 
  def write(self, oprot):
18137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18139 
      return
18140 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18141 
    if self.warehouseId is not None:
2690 chandransh 18142 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18143 
      oprot.writeI64(self.warehouseId)
18144 
      oprot.writeFieldEnd()
3431 rajveer 18145 
    if self.fromDate is not None:
2690 chandransh 18146 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18147 
      oprot.writeI64(self.fromDate)
18148 
      oprot.writeFieldEnd()
3431 rajveer 18149 
    if self.toDate is not None:
2690 chandransh 18150 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18151 
      oprot.writeI64(self.toDate)
18152 
      oprot.writeFieldEnd()
18153 
    oprot.writeFieldStop()
18154 
    oprot.writeStructEnd()
18155 
 
3431 rajveer 18156 
  def validate(self):
18157 
    return
18158 
 
18159 
 
2690 chandransh 18160 
  def __repr__(self):
18161 
    L = ['%s=%r' % (key, value)
18162 
      for key, value in self.__dict__.iteritems()]
18163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18164 
 
18165 
  def __eq__(self, other):
18166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18167 
 
18168 
  def __ne__(self, other):
18169 
    return not (self == other)
18170 
 
18171 
class getReturnOrders_result:
18172 
  """
18173 
  Attributes:
18174 
   - success
18175 
  """
18176 
 
18177 
  thrift_spec = (
18178 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18179 
  )
18180 
 
18181 
  def __init__(self, success=None,):
18182 
    self.success = success
18183 
 
18184 
  def read(self, iprot):
18185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18187 
      return
18188 
    iprot.readStructBegin()
18189 
    while True:
18190 
      (fname, ftype, fid) = iprot.readFieldBegin()
18191 
      if ftype == TType.STOP:
18192 
        break
18193 
      if fid == 0:
18194 
        if ftype == TType.LIST:
18195 
          self.success = []
6031 rajveer 18196 
          (_etype399, _size396) = iprot.readListBegin()
18197 
          for _i400 in xrange(_size396):
18198 
            _elem401 = ReturnOrder()
18199 
            _elem401.read(iprot)
18200 
            self.success.append(_elem401)
2690 chandransh 18201 
          iprot.readListEnd()
18202 
        else:
18203 
          iprot.skip(ftype)
18204 
      else:
18205 
        iprot.skip(ftype)
18206 
      iprot.readFieldEnd()
18207 
    iprot.readStructEnd()
18208 
 
18209 
  def write(self, oprot):
18210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18212 
      return
18213 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18214 
    if self.success is not None:
2690 chandransh 18215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18217 
      for iter402 in self.success:
18218 
        iter402.write(oprot)
2690 chandransh 18219 
      oprot.writeListEnd()
18220 
      oprot.writeFieldEnd()
18221 
    oprot.writeFieldStop()
18222 
    oprot.writeStructEnd()
18223 
 
3431 rajveer 18224 
  def validate(self):
18225 
    return
18226 
 
18227 
 
2690 chandransh 18228 
  def __repr__(self):
18229 
    L = ['%s=%r' % (key, value)
18230 
      for key, value in self.__dict__.iteritems()]
18231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18232 
 
18233 
  def __eq__(self, other):
18234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18235 
 
18236 
  def __ne__(self, other):
18237 
    return not (self == other)
18238 
 
5481 phani.kuma 18239 
class getAllReturnOrders_args:
18240 
  """
18241 
  Attributes:
18242 
   - onlyNotProcessed
18243 
   - fromDate
18244 
   - toDate
18245 
  """
18246 
 
18247 
  thrift_spec = (
18248 
    None, # 0
18249 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18250 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18251 
    (3, TType.I64, 'toDate', None, None, ), # 3
18252 
  )
18253 
 
18254 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18255 
    self.onlyNotProcessed = onlyNotProcessed
18256 
    self.fromDate = fromDate
18257 
    self.toDate = toDate
18258 
 
18259 
  def read(self, iprot):
18260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18262 
      return
18263 
    iprot.readStructBegin()
18264 
    while True:
18265 
      (fname, ftype, fid) = iprot.readFieldBegin()
18266 
      if ftype == TType.STOP:
18267 
        break
18268 
      if fid == 1:
18269 
        if ftype == TType.BOOL:
18270 
          self.onlyNotProcessed = iprot.readBool();
18271 
        else:
18272 
          iprot.skip(ftype)
18273 
      elif fid == 2:
18274 
        if ftype == TType.I64:
18275 
          self.fromDate = iprot.readI64();
18276 
        else:
18277 
          iprot.skip(ftype)
18278 
      elif fid == 3:
18279 
        if ftype == TType.I64:
18280 
          self.toDate = iprot.readI64();
18281 
        else:
18282 
          iprot.skip(ftype)
18283 
      else:
18284 
        iprot.skip(ftype)
18285 
      iprot.readFieldEnd()
18286 
    iprot.readStructEnd()
18287 
 
18288 
  def write(self, oprot):
18289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18291 
      return
18292 
    oprot.writeStructBegin('getAllReturnOrders_args')
18293 
    if self.onlyNotProcessed is not None:
18294 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18295 
      oprot.writeBool(self.onlyNotProcessed)
18296 
      oprot.writeFieldEnd()
18297 
    if self.fromDate is not None:
18298 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18299 
      oprot.writeI64(self.fromDate)
18300 
      oprot.writeFieldEnd()
18301 
    if self.toDate is not None:
18302 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18303 
      oprot.writeI64(self.toDate)
18304 
      oprot.writeFieldEnd()
18305 
    oprot.writeFieldStop()
18306 
    oprot.writeStructEnd()
18307 
 
18308 
  def validate(self):
18309 
    return
18310 
 
18311 
 
18312 
  def __repr__(self):
18313 
    L = ['%s=%r' % (key, value)
18314 
      for key, value in self.__dict__.iteritems()]
18315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18316 
 
18317 
  def __eq__(self, other):
18318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18319 
 
18320 
  def __ne__(self, other):
18321 
    return not (self == other)
18322 
 
18323 
class getAllReturnOrders_result:
18324 
  """
18325 
  Attributes:
18326 
   - success
18327 
  """
18328 
 
18329 
  thrift_spec = (
18330 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18331 
  )
18332 
 
18333 
  def __init__(self, success=None,):
18334 
    self.success = success
18335 
 
18336 
  def read(self, iprot):
18337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18339 
      return
18340 
    iprot.readStructBegin()
18341 
    while True:
18342 
      (fname, ftype, fid) = iprot.readFieldBegin()
18343 
      if ftype == TType.STOP:
18344 
        break
18345 
      if fid == 0:
18346 
        if ftype == TType.LIST:
18347 
          self.success = []
6031 rajveer 18348 
          (_etype406, _size403) = iprot.readListBegin()
18349 
          for _i407 in xrange(_size403):
18350 
            _elem408 = ReturnOrder()
18351 
            _elem408.read(iprot)
18352 
            self.success.append(_elem408)
5481 phani.kuma 18353 
          iprot.readListEnd()
18354 
        else:
18355 
          iprot.skip(ftype)
18356 
      else:
18357 
        iprot.skip(ftype)
18358 
      iprot.readFieldEnd()
18359 
    iprot.readStructEnd()
18360 
 
18361 
  def write(self, oprot):
18362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18364 
      return
18365 
    oprot.writeStructBegin('getAllReturnOrders_result')
18366 
    if self.success is not None:
18367 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18368 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 18369 
      for iter409 in self.success:
18370 
        iter409.write(oprot)
5481 phani.kuma 18371 
      oprot.writeListEnd()
18372 
      oprot.writeFieldEnd()
18373 
    oprot.writeFieldStop()
18374 
    oprot.writeStructEnd()
18375 
 
18376 
  def validate(self):
18377 
    return
18378 
 
18379 
 
18380 
  def __repr__(self):
18381 
    L = ['%s=%r' % (key, value)
18382 
      for key, value in self.__dict__.iteritems()]
18383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18384 
 
18385 
  def __eq__(self, other):
18386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18387 
 
18388 
  def __ne__(self, other):
18389 
    return not (self == other)
18390 
 
2700 chandransh 18391 
class getReturnOrder_args:
18392 
  """
18393 
  Attributes:
18394 
   - id
18395 
  """
18396 
 
18397 
  thrift_spec = (
18398 
    None, # 0
18399 
    (1, TType.I64, 'id', None, None, ), # 1
18400 
  )
18401 
 
18402 
  def __init__(self, id=None,):
18403 
    self.id = id
18404 
 
18405 
  def read(self, iprot):
18406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18408 
      return
18409 
    iprot.readStructBegin()
18410 
    while True:
18411 
      (fname, ftype, fid) = iprot.readFieldBegin()
18412 
      if ftype == TType.STOP:
18413 
        break
18414 
      if fid == 1:
18415 
        if ftype == TType.I64:
18416 
          self.id = iprot.readI64();
18417 
        else:
18418 
          iprot.skip(ftype)
18419 
      else:
18420 
        iprot.skip(ftype)
18421 
      iprot.readFieldEnd()
18422 
    iprot.readStructEnd()
18423 
 
18424 
  def write(self, oprot):
18425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18427 
      return
18428 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18429 
    if self.id is not None:
2700 chandransh 18430 
      oprot.writeFieldBegin('id', TType.I64, 1)
18431 
      oprot.writeI64(self.id)
18432 
      oprot.writeFieldEnd()
18433 
    oprot.writeFieldStop()
18434 
    oprot.writeStructEnd()
18435 
 
3431 rajveer 18436 
  def validate(self):
18437 
    return
18438 
 
18439 
 
2700 chandransh 18440 
  def __repr__(self):
18441 
    L = ['%s=%r' % (key, value)
18442 
      for key, value in self.__dict__.iteritems()]
18443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18444 
 
18445 
  def __eq__(self, other):
18446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18447 
 
18448 
  def __ne__(self, other):
18449 
    return not (self == other)
18450 
 
18451 
class getReturnOrder_result:
18452 
  """
18453 
  Attributes:
18454 
   - success
18455 
   - ex
18456 
  """
18457 
 
18458 
  thrift_spec = (
18459 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18460 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18461 
  )
18462 
 
18463 
  def __init__(self, success=None, ex=None,):
18464 
    self.success = success
18465 
    self.ex = ex
18466 
 
18467 
  def read(self, iprot):
18468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18470 
      return
18471 
    iprot.readStructBegin()
18472 
    while True:
18473 
      (fname, ftype, fid) = iprot.readFieldBegin()
18474 
      if ftype == TType.STOP:
18475 
        break
18476 
      if fid == 0:
18477 
        if ftype == TType.STRUCT:
18478 
          self.success = ReturnOrder()
18479 
          self.success.read(iprot)
18480 
        else:
18481 
          iprot.skip(ftype)
18482 
      elif fid == 1:
18483 
        if ftype == TType.STRUCT:
18484 
          self.ex = TransactionServiceException()
18485 
          self.ex.read(iprot)
18486 
        else:
18487 
          iprot.skip(ftype)
18488 
      else:
18489 
        iprot.skip(ftype)
18490 
      iprot.readFieldEnd()
18491 
    iprot.readStructEnd()
18492 
 
18493 
  def write(self, oprot):
18494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18496 
      return
18497 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18498 
    if self.success is not None:
2700 chandransh 18499 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18500 
      self.success.write(oprot)
18501 
      oprot.writeFieldEnd()
3431 rajveer 18502 
    if self.ex is not None:
2700 chandransh 18503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18504 
      self.ex.write(oprot)
18505 
      oprot.writeFieldEnd()
18506 
    oprot.writeFieldStop()
18507 
    oprot.writeStructEnd()
18508 
 
3431 rajveer 18509 
  def validate(self):
18510 
    return
18511 
 
18512 
 
2700 chandransh 18513 
  def __repr__(self):
18514 
    L = ['%s=%r' % (key, value)
18515 
      for key, value in self.__dict__.iteritems()]
18516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18517 
 
18518 
  def __eq__(self, other):
18519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18520 
 
18521 
  def __ne__(self, other):
18522 
    return not (self == other)
18523 
 
2690 chandransh 18524 
class processReturn_args:
18525 
  """
18526 
  Attributes:
18527 
   - returnOrderId
18528 
  """
18529 
 
18530 
  thrift_spec = (
18531 
    None, # 0
18532 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18533 
  )
18534 
 
18535 
  def __init__(self, returnOrderId=None,):
18536 
    self.returnOrderId = returnOrderId
18537 
 
18538 
  def read(self, iprot):
18539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18541 
      return
18542 
    iprot.readStructBegin()
18543 
    while True:
18544 
      (fname, ftype, fid) = iprot.readFieldBegin()
18545 
      if ftype == TType.STOP:
18546 
        break
18547 
      if fid == 1:
18548 
        if ftype == TType.I64:
18549 
          self.returnOrderId = iprot.readI64();
18550 
        else:
18551 
          iprot.skip(ftype)
18552 
      else:
18553 
        iprot.skip(ftype)
18554 
      iprot.readFieldEnd()
18555 
    iprot.readStructEnd()
18556 
 
18557 
  def write(self, oprot):
18558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18560 
      return
18561 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18562 
    if self.returnOrderId is not None:
2690 chandransh 18563 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18564 
      oprot.writeI64(self.returnOrderId)
18565 
      oprot.writeFieldEnd()
18566 
    oprot.writeFieldStop()
18567 
    oprot.writeStructEnd()
18568 
 
3431 rajveer 18569 
  def validate(self):
18570 
    return
18571 
 
18572 
 
2690 chandransh 18573 
  def __repr__(self):
18574 
    L = ['%s=%r' % (key, value)
18575 
      for key, value in self.__dict__.iteritems()]
18576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18577 
 
18578 
  def __eq__(self, other):
18579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18580 
 
18581 
  def __ne__(self, other):
18582 
    return not (self == other)
18583 
 
18584 
class processReturn_result:
18585 
  """
18586 
  Attributes:
18587 
   - ex
18588 
  """
18589 
 
18590 
  thrift_spec = (
18591 
    None, # 0
18592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18593 
  )
18594 
 
18595 
  def __init__(self, ex=None,):
18596 
    self.ex = ex
18597 
 
18598 
  def read(self, iprot):
18599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18601 
      return
18602 
    iprot.readStructBegin()
18603 
    while True:
18604 
      (fname, ftype, fid) = iprot.readFieldBegin()
18605 
      if ftype == TType.STOP:
18606 
        break
18607 
      if fid == 1:
18608 
        if ftype == TType.STRUCT:
18609 
          self.ex = TransactionServiceException()
18610 
          self.ex.read(iprot)
18611 
        else:
18612 
          iprot.skip(ftype)
18613 
      else:
18614 
        iprot.skip(ftype)
18615 
      iprot.readFieldEnd()
18616 
    iprot.readStructEnd()
18617 
 
18618 
  def write(self, oprot):
18619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18621 
      return
18622 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18623 
    if self.ex is not None:
2690 chandransh 18624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18625 
      self.ex.write(oprot)
18626 
      oprot.writeFieldEnd()
18627 
    oprot.writeFieldStop()
18628 
    oprot.writeStructEnd()
18629 
 
3431 rajveer 18630 
  def validate(self):
18631 
    return
18632 
 
18633 
 
2690 chandransh 18634 
  def __repr__(self):
18635 
    L = ['%s=%r' % (key, value)
18636 
      for key, value in self.__dict__.iteritems()]
18637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18638 
 
18639 
  def __eq__(self, other):
18640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18641 
 
18642 
  def __ne__(self, other):
18643 
    return not (self == other)
18644 
 
3451 chandransh 18645 
class updateWeight_args:
18646 
  """
18647 
  Attributes:
18648 
   - orderId
18649 
   - weight
18650 
  """
18651 
 
18652 
  thrift_spec = (
18653 
    None, # 0
18654 
    (1, TType.I64, 'orderId', None, None, ), # 1
18655 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18656 
  )
18657 
 
18658 
  def __init__(self, orderId=None, weight=None,):
18659 
    self.orderId = orderId
18660 
    self.weight = weight
18661 
 
18662 
  def read(self, iprot):
18663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18665 
      return
18666 
    iprot.readStructBegin()
18667 
    while True:
18668 
      (fname, ftype, fid) = iprot.readFieldBegin()
18669 
      if ftype == TType.STOP:
18670 
        break
18671 
      if fid == 1:
18672 
        if ftype == TType.I64:
18673 
          self.orderId = iprot.readI64();
18674 
        else:
18675 
          iprot.skip(ftype)
18676 
      elif fid == 2:
18677 
        if ftype == TType.DOUBLE:
18678 
          self.weight = iprot.readDouble();
18679 
        else:
18680 
          iprot.skip(ftype)
18681 
      else:
18682 
        iprot.skip(ftype)
18683 
      iprot.readFieldEnd()
18684 
    iprot.readStructEnd()
18685 
 
18686 
  def write(self, oprot):
18687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18689 
      return
18690 
    oprot.writeStructBegin('updateWeight_args')
18691 
    if self.orderId is not None:
18692 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18693 
      oprot.writeI64(self.orderId)
18694 
      oprot.writeFieldEnd()
18695 
    if self.weight is not None:
18696 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18697 
      oprot.writeDouble(self.weight)
18698 
      oprot.writeFieldEnd()
18699 
    oprot.writeFieldStop()
18700 
    oprot.writeStructEnd()
18701 
 
18702 
  def validate(self):
18703 
    return
18704 
 
18705 
 
18706 
  def __repr__(self):
18707 
    L = ['%s=%r' % (key, value)
18708 
      for key, value in self.__dict__.iteritems()]
18709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18710 
 
18711 
  def __eq__(self, other):
18712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18713 
 
18714 
  def __ne__(self, other):
18715 
    return not (self == other)
18716 
 
18717 
class updateWeight_result:
18718 
  """
18719 
  Attributes:
18720 
   - success
18721 
   - ex
18722 
  """
18723 
 
18724 
  thrift_spec = (
18725 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18727 
  )
18728 
 
18729 
  def __init__(self, success=None, ex=None,):
18730 
    self.success = success
18731 
    self.ex = ex
18732 
 
18733 
  def read(self, iprot):
18734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18736 
      return
18737 
    iprot.readStructBegin()
18738 
    while True:
18739 
      (fname, ftype, fid) = iprot.readFieldBegin()
18740 
      if ftype == TType.STOP:
18741 
        break
18742 
      if fid == 0:
18743 
        if ftype == TType.STRUCT:
18744 
          self.success = Order()
18745 
          self.success.read(iprot)
18746 
        else:
18747 
          iprot.skip(ftype)
18748 
      elif fid == 1:
18749 
        if ftype == TType.STRUCT:
18750 
          self.ex = TransactionServiceException()
18751 
          self.ex.read(iprot)
18752 
        else:
18753 
          iprot.skip(ftype)
18754 
      else:
18755 
        iprot.skip(ftype)
18756 
      iprot.readFieldEnd()
18757 
    iprot.readStructEnd()
18758 
 
18759 
  def write(self, oprot):
18760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18762 
      return
18763 
    oprot.writeStructBegin('updateWeight_result')
18764 
    if self.success is not None:
18765 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18766 
      self.success.write(oprot)
18767 
      oprot.writeFieldEnd()
18768 
    if self.ex is not None:
18769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18770 
      self.ex.write(oprot)
18771 
      oprot.writeFieldEnd()
18772 
    oprot.writeFieldStop()
18773 
    oprot.writeStructEnd()
18774 
 
18775 
  def validate(self):
18776 
    return
18777 
 
18778 
 
18779 
  def __repr__(self):
18780 
    L = ['%s=%r' % (key, value)
18781 
      for key, value in self.__dict__.iteritems()]
18782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18783 
 
18784 
  def __eq__(self, other):
18785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18786 
 
18787 
  def __ne__(self, other):
18788 
    return not (self == other)
3469 chandransh 18789 
 
18790 
class changeItem_args:
18791 
  """
18792 
  Attributes:
18793 
   - orderId
18794 
   - itemId
18795 
  """
18796 
 
18797 
  thrift_spec = (
18798 
    None, # 0
18799 
    (1, TType.I64, 'orderId', None, None, ), # 1
18800 
    (2, TType.I64, 'itemId', None, None, ), # 2
18801 
  )
18802 
 
18803 
  def __init__(self, orderId=None, itemId=None,):
18804 
    self.orderId = orderId
18805 
    self.itemId = itemId
18806 
 
18807 
  def read(self, iprot):
18808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18810 
      return
18811 
    iprot.readStructBegin()
18812 
    while True:
18813 
      (fname, ftype, fid) = iprot.readFieldBegin()
18814 
      if ftype == TType.STOP:
18815 
        break
18816 
      if fid == 1:
18817 
        if ftype == TType.I64:
18818 
          self.orderId = iprot.readI64();
18819 
        else:
18820 
          iprot.skip(ftype)
18821 
      elif fid == 2:
18822 
        if ftype == TType.I64:
18823 
          self.itemId = iprot.readI64();
18824 
        else:
18825 
          iprot.skip(ftype)
18826 
      else:
18827 
        iprot.skip(ftype)
18828 
      iprot.readFieldEnd()
18829 
    iprot.readStructEnd()
18830 
 
18831 
  def write(self, oprot):
18832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18834 
      return
18835 
    oprot.writeStructBegin('changeItem_args')
18836 
    if self.orderId is not None:
18837 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18838 
      oprot.writeI64(self.orderId)
18839 
      oprot.writeFieldEnd()
18840 
    if self.itemId is not None:
18841 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
18842 
      oprot.writeI64(self.itemId)
18843 
      oprot.writeFieldEnd()
18844 
    oprot.writeFieldStop()
18845 
    oprot.writeStructEnd()
18846 
 
18847 
  def validate(self):
18848 
    return
18849 
 
18850 
 
18851 
  def __repr__(self):
18852 
    L = ['%s=%r' % (key, value)
18853 
      for key, value in self.__dict__.iteritems()]
18854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18855 
 
18856 
  def __eq__(self, other):
18857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18858 
 
18859 
  def __ne__(self, other):
18860 
    return not (self == other)
18861 
 
18862 
class changeItem_result:
18863 
  """
18864 
  Attributes:
18865 
   - success
18866 
   - ex
18867 
  """
18868 
 
18869 
  thrift_spec = (
18870 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18871 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18872 
  )
18873 
 
18874 
  def __init__(self, success=None, ex=None,):
18875 
    self.success = success
18876 
    self.ex = ex
18877 
 
18878 
  def read(self, iprot):
18879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18881 
      return
18882 
    iprot.readStructBegin()
18883 
    while True:
18884 
      (fname, ftype, fid) = iprot.readFieldBegin()
18885 
      if ftype == TType.STOP:
18886 
        break
18887 
      if fid == 0:
18888 
        if ftype == TType.STRUCT:
18889 
          self.success = Order()
18890 
          self.success.read(iprot)
18891 
        else:
18892 
          iprot.skip(ftype)
18893 
      elif fid == 1:
18894 
        if ftype == TType.STRUCT:
18895 
          self.ex = TransactionServiceException()
18896 
          self.ex.read(iprot)
18897 
        else:
18898 
          iprot.skip(ftype)
18899 
      else:
18900 
        iprot.skip(ftype)
18901 
      iprot.readFieldEnd()
18902 
    iprot.readStructEnd()
18903 
 
18904 
  def write(self, oprot):
18905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18907 
      return
18908 
    oprot.writeStructBegin('changeItem_result')
18909 
    if self.success is not None:
18910 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18911 
      self.success.write(oprot)
18912 
      oprot.writeFieldEnd()
18913 
    if self.ex is not None:
18914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18915 
      self.ex.write(oprot)
18916 
      oprot.writeFieldEnd()
18917 
    oprot.writeFieldStop()
18918 
    oprot.writeStructEnd()
18919 
 
18920 
  def validate(self):
18921 
    return
18922 
 
18923 
 
18924 
  def __repr__(self):
18925 
    L = ['%s=%r' % (key, value)
18926 
      for key, value in self.__dict__.iteritems()]
18927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18928 
 
18929 
  def __eq__(self, other):
18930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18931 
 
18932 
  def __ne__(self, other):
18933 
    return not (self == other)
18934 
 
18935 
class shiftToWarehouse_args:
18936 
  """
18937 
  Attributes:
18938 
   - orderId
18939 
   - warehouseId
18940 
  """
18941 
 
18942 
  thrift_spec = (
18943 
    None, # 0
18944 
    (1, TType.I64, 'orderId', None, None, ), # 1
18945 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
18946 
  )
18947 
 
18948 
  def __init__(self, orderId=None, warehouseId=None,):
18949 
    self.orderId = orderId
18950 
    self.warehouseId = warehouseId
18951 
 
18952 
  def read(self, iprot):
18953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18955 
      return
18956 
    iprot.readStructBegin()
18957 
    while True:
18958 
      (fname, ftype, fid) = iprot.readFieldBegin()
18959 
      if ftype == TType.STOP:
18960 
        break
18961 
      if fid == 1:
18962 
        if ftype == TType.I64:
18963 
          self.orderId = iprot.readI64();
18964 
        else:
18965 
          iprot.skip(ftype)
18966 
      elif fid == 2:
18967 
        if ftype == TType.I64:
18968 
          self.warehouseId = iprot.readI64();
18969 
        else:
18970 
          iprot.skip(ftype)
18971 
      else:
18972 
        iprot.skip(ftype)
18973 
      iprot.readFieldEnd()
18974 
    iprot.readStructEnd()
18975 
 
18976 
  def write(self, oprot):
18977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18979 
      return
18980 
    oprot.writeStructBegin('shiftToWarehouse_args')
18981 
    if self.orderId is not None:
18982 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18983 
      oprot.writeI64(self.orderId)
18984 
      oprot.writeFieldEnd()
18985 
    if self.warehouseId is not None:
18986 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
18987 
      oprot.writeI64(self.warehouseId)
18988 
      oprot.writeFieldEnd()
18989 
    oprot.writeFieldStop()
18990 
    oprot.writeStructEnd()
18991 
 
18992 
  def validate(self):
18993 
    return
18994 
 
18995 
 
18996 
  def __repr__(self):
18997 
    L = ['%s=%r' % (key, value)
18998 
      for key, value in self.__dict__.iteritems()]
18999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19000 
 
19001 
  def __eq__(self, other):
19002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19003 
 
19004 
  def __ne__(self, other):
19005 
    return not (self == other)
19006 
 
19007 
class shiftToWarehouse_result:
19008 
  """
19009 
  Attributes:
19010 
   - success
19011 
   - ex
19012 
  """
19013 
 
19014 
  thrift_spec = (
19015 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19017 
  )
19018 
 
19019 
  def __init__(self, success=None, ex=None,):
19020 
    self.success = success
19021 
    self.ex = ex
19022 
 
19023 
  def read(self, iprot):
19024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19026 
      return
19027 
    iprot.readStructBegin()
19028 
    while True:
19029 
      (fname, ftype, fid) = iprot.readFieldBegin()
19030 
      if ftype == TType.STOP:
19031 
        break
19032 
      if fid == 0:
19033 
        if ftype == TType.STRUCT:
19034 
          self.success = Order()
19035 
          self.success.read(iprot)
19036 
        else:
19037 
          iprot.skip(ftype)
19038 
      elif fid == 1:
19039 
        if ftype == TType.STRUCT:
19040 
          self.ex = TransactionServiceException()
19041 
          self.ex.read(iprot)
19042 
        else:
19043 
          iprot.skip(ftype)
19044 
      else:
19045 
        iprot.skip(ftype)
19046 
      iprot.readFieldEnd()
19047 
    iprot.readStructEnd()
19048 
 
19049 
  def write(self, oprot):
19050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19052 
      return
19053 
    oprot.writeStructBegin('shiftToWarehouse_result')
19054 
    if self.success is not None:
19055 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19056 
      self.success.write(oprot)
19057 
      oprot.writeFieldEnd()
19058 
    if self.ex is not None:
19059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19060 
      self.ex.write(oprot)
19061 
      oprot.writeFieldEnd()
19062 
    oprot.writeFieldStop()
19063 
    oprot.writeStructEnd()
19064 
 
19065 
  def validate(self):
19066 
    return
19067 
 
19068 
 
19069 
  def __repr__(self):
19070 
    L = ['%s=%r' % (key, value)
19071 
      for key, value in self.__dict__.iteritems()]
19072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19073 
 
19074 
  def __eq__(self, other):
19075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19076 
 
19077 
  def __ne__(self, other):
19078 
    return not (self == other)
3553 chandransh 19079 
 
19080 
class addDelayReason_args:
19081 
  """
19082 
  Attributes:
19083 
   - orderId
19084 
   - delayReason
3986 chandransh 19085 
   - furtherDelay
4647 rajveer 19086 
   - delayReasonText
3553 chandransh 19087 
  """
19088 
 
19089 
  thrift_spec = (
19090 
    None, # 0
19091 
    (1, TType.I64, 'orderId', None, None, ), # 1
19092 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19093 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19094 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19095 
  )
19096 
 
4647 rajveer 19097 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19098 
    self.orderId = orderId
19099 
    self.delayReason = delayReason
3986 chandransh 19100 
    self.furtherDelay = furtherDelay
4647 rajveer 19101 
    self.delayReasonText = delayReasonText
3553 chandransh 19102 
 
19103 
  def read(self, iprot):
19104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19106 
      return
19107 
    iprot.readStructBegin()
19108 
    while True:
19109 
      (fname, ftype, fid) = iprot.readFieldBegin()
19110 
      if ftype == TType.STOP:
19111 
        break
19112 
      if fid == 1:
19113 
        if ftype == TType.I64:
19114 
          self.orderId = iprot.readI64();
19115 
        else:
19116 
          iprot.skip(ftype)
19117 
      elif fid == 2:
19118 
        if ftype == TType.I32:
19119 
          self.delayReason = iprot.readI32();
19120 
        else:
19121 
          iprot.skip(ftype)
3986 chandransh 19122 
      elif fid == 3:
19123 
        if ftype == TType.I64:
19124 
          self.furtherDelay = iprot.readI64();
19125 
        else:
19126 
          iprot.skip(ftype)
4647 rajveer 19127 
      elif fid == 4:
19128 
        if ftype == TType.STRING:
19129 
          self.delayReasonText = iprot.readString();
19130 
        else:
19131 
          iprot.skip(ftype)
3553 chandransh 19132 
      else:
19133 
        iprot.skip(ftype)
19134 
      iprot.readFieldEnd()
19135 
    iprot.readStructEnd()
19136 
 
19137 
  def write(self, oprot):
19138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19140 
      return
19141 
    oprot.writeStructBegin('addDelayReason_args')
19142 
    if self.orderId is not None:
19143 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19144 
      oprot.writeI64(self.orderId)
19145 
      oprot.writeFieldEnd()
19146 
    if self.delayReason is not None:
19147 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19148 
      oprot.writeI32(self.delayReason)
19149 
      oprot.writeFieldEnd()
3986 chandransh 19150 
    if self.furtherDelay is not None:
19151 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19152 
      oprot.writeI64(self.furtherDelay)
19153 
      oprot.writeFieldEnd()
4647 rajveer 19154 
    if self.delayReasonText is not None:
19155 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19156 
      oprot.writeString(self.delayReasonText)
19157 
      oprot.writeFieldEnd()
3553 chandransh 19158 
    oprot.writeFieldStop()
19159 
    oprot.writeStructEnd()
19160 
 
19161 
  def validate(self):
19162 
    return
19163 
 
19164 
 
19165 
  def __repr__(self):
19166 
    L = ['%s=%r' % (key, value)
19167 
      for key, value in self.__dict__.iteritems()]
19168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19169 
 
19170 
  def __eq__(self, other):
19171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19172 
 
19173 
  def __ne__(self, other):
19174 
    return not (self == other)
19175 
 
19176 
class addDelayReason_result:
19177 
  """
19178 
  Attributes:
19179 
   - success
19180 
   - ex
19181 
  """
19182 
 
19183 
  thrift_spec = (
19184 
    (0, TType.BOOL, 'success', None, None, ), # 0
19185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19186 
  )
19187 
 
19188 
  def __init__(self, success=None, ex=None,):
19189 
    self.success = success
19190 
    self.ex = ex
19191 
 
19192 
  def read(self, iprot):
19193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19195 
      return
19196 
    iprot.readStructBegin()
19197 
    while True:
19198 
      (fname, ftype, fid) = iprot.readFieldBegin()
19199 
      if ftype == TType.STOP:
19200 
        break
19201 
      if fid == 0:
19202 
        if ftype == TType.BOOL:
19203 
          self.success = iprot.readBool();
19204 
        else:
19205 
          iprot.skip(ftype)
19206 
      elif fid == 1:
19207 
        if ftype == TType.STRUCT:
19208 
          self.ex = TransactionServiceException()
19209 
          self.ex.read(iprot)
19210 
        else:
19211 
          iprot.skip(ftype)
19212 
      else:
19213 
        iprot.skip(ftype)
19214 
      iprot.readFieldEnd()
19215 
    iprot.readStructEnd()
19216 
 
19217 
  def write(self, oprot):
19218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19220 
      return
19221 
    oprot.writeStructBegin('addDelayReason_result')
19222 
    if self.success is not None:
19223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19224 
      oprot.writeBool(self.success)
19225 
      oprot.writeFieldEnd()
19226 
    if self.ex is not None:
19227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19228 
      self.ex.write(oprot)
19229 
      oprot.writeFieldEnd()
19230 
    oprot.writeFieldStop()
19231 
    oprot.writeStructEnd()
19232 
 
19233 
  def validate(self):
19234 
    return
19235 
 
19236 
 
19237 
  def __repr__(self):
19238 
    L = ['%s=%r' % (key, value)
19239 
      for key, value in self.__dict__.iteritems()]
19240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19241 
 
19242 
  def __eq__(self, other):
19243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19244 
 
19245 
  def __ne__(self, other):
19246 
    return not (self == other)
3956 chandransh 19247 
 
19248 
class reconcileCodCollection_args:
19249 
  """
19250 
  Attributes:
19251 
   - collectedAmountMap
19252 
   - xferBy
19253 
   - xferTxnId
19254 
   - xferDate
19255 
  """
19256 
 
19257 
  thrift_spec = (
19258 
    None, # 0
19259 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19260 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19261 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19262 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19263 
  )
19264 
 
19265 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19266 
    self.collectedAmountMap = collectedAmountMap
19267 
    self.xferBy = xferBy
19268 
    self.xferTxnId = xferTxnId
19269 
    self.xferDate = xferDate
19270 
 
19271 
  def read(self, iprot):
19272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19274 
      return
19275 
    iprot.readStructBegin()
19276 
    while True:
19277 
      (fname, ftype, fid) = iprot.readFieldBegin()
19278 
      if ftype == TType.STOP:
19279 
        break
19280 
      if fid == 1:
19281 
        if ftype == TType.MAP:
19282 
          self.collectedAmountMap = {}
6031 rajveer 19283 
          (_ktype411, _vtype412, _size410 ) = iprot.readMapBegin()
19284 
          for _i414 in xrange(_size410):
19285 
            _key415 = iprot.readString();
19286 
            _val416 = iprot.readDouble();
19287 
            self.collectedAmountMap[_key415] = _val416
3956 chandransh 19288 
          iprot.readMapEnd()
19289 
        else:
19290 
          iprot.skip(ftype)
19291 
      elif fid == 2:
19292 
        if ftype == TType.STRING:
19293 
          self.xferBy = iprot.readString();
19294 
        else:
19295 
          iprot.skip(ftype)
19296 
      elif fid == 3:
19297 
        if ftype == TType.STRING:
19298 
          self.xferTxnId = iprot.readString();
19299 
        else:
19300 
          iprot.skip(ftype)
19301 
      elif fid == 4:
19302 
        if ftype == TType.I64:
19303 
          self.xferDate = iprot.readI64();
19304 
        else:
19305 
          iprot.skip(ftype)
19306 
      else:
19307 
        iprot.skip(ftype)
19308 
      iprot.readFieldEnd()
19309 
    iprot.readStructEnd()
19310 
 
19311 
  def write(self, oprot):
19312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19314 
      return
19315 
    oprot.writeStructBegin('reconcileCodCollection_args')
19316 
    if self.collectedAmountMap is not None:
19317 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19318 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6031 rajveer 19319 
      for kiter417,viter418 in self.collectedAmountMap.items():
19320 
        oprot.writeString(kiter417)
19321 
        oprot.writeDouble(viter418)
3956 chandransh 19322 
      oprot.writeMapEnd()
19323 
      oprot.writeFieldEnd()
19324 
    if self.xferBy is not None:
19325 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19326 
      oprot.writeString(self.xferBy)
19327 
      oprot.writeFieldEnd()
19328 
    if self.xferTxnId is not None:
19329 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19330 
      oprot.writeString(self.xferTxnId)
19331 
      oprot.writeFieldEnd()
19332 
    if self.xferDate is not None:
19333 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19334 
      oprot.writeI64(self.xferDate)
19335 
      oprot.writeFieldEnd()
19336 
    oprot.writeFieldStop()
19337 
    oprot.writeStructEnd()
19338 
 
19339 
  def validate(self):
19340 
    return
19341 
 
19342 
 
19343 
  def __repr__(self):
19344 
    L = ['%s=%r' % (key, value)
19345 
      for key, value in self.__dict__.iteritems()]
19346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19347 
 
19348 
  def __eq__(self, other):
19349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19350 
 
19351 
  def __ne__(self, other):
19352 
    return not (self == other)
19353 
 
19354 
class reconcileCodCollection_result:
19355 
  """
19356 
  Attributes:
19357 
   - success
19358 
   - ex
19359 
  """
19360 
 
19361 
  thrift_spec = (
19362 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19364 
  )
19365 
 
19366 
  def __init__(self, success=None, ex=None,):
19367 
    self.success = success
19368 
    self.ex = ex
19369 
 
19370 
  def read(self, iprot):
19371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19373 
      return
19374 
    iprot.readStructBegin()
19375 
    while True:
19376 
      (fname, ftype, fid) = iprot.readFieldBegin()
19377 
      if ftype == TType.STOP:
19378 
        break
19379 
      if fid == 0:
19380 
        if ftype == TType.MAP:
19381 
          self.success = {}
6031 rajveer 19382 
          (_ktype420, _vtype421, _size419 ) = iprot.readMapBegin()
19383 
          for _i423 in xrange(_size419):
19384 
            _key424 = iprot.readString();
19385 
            _val425 = iprot.readString();
19386 
            self.success[_key424] = _val425
3956 chandransh 19387 
          iprot.readMapEnd()
19388 
        else:
19389 
          iprot.skip(ftype)
19390 
      elif fid == 1:
19391 
        if ftype == TType.STRUCT:
19392 
          self.ex = TransactionServiceException()
19393 
          self.ex.read(iprot)
19394 
        else:
19395 
          iprot.skip(ftype)
19396 
      else:
19397 
        iprot.skip(ftype)
19398 
      iprot.readFieldEnd()
19399 
    iprot.readStructEnd()
19400 
 
19401 
  def write(self, oprot):
19402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19404 
      return
19405 
    oprot.writeStructBegin('reconcileCodCollection_result')
19406 
    if self.success is not None:
19407 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19408 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6031 rajveer 19409 
      for kiter426,viter427 in self.success.items():
19410 
        oprot.writeString(kiter426)
19411 
        oprot.writeString(viter427)
3956 chandransh 19412 
      oprot.writeMapEnd()
19413 
      oprot.writeFieldEnd()
19414 
    if self.ex is not None:
19415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19416 
      self.ex.write(oprot)
19417 
      oprot.writeFieldEnd()
19418 
    oprot.writeFieldStop()
19419 
    oprot.writeStructEnd()
19420 
 
19421 
  def validate(self):
19422 
    return
19423 
 
19424 
 
19425 
  def __repr__(self):
19426 
    L = ['%s=%r' % (key, value)
19427 
      for key, value in self.__dict__.iteritems()]
19428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19429 
 
19430 
  def __eq__(self, other):
19431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19432 
 
19433 
  def __ne__(self, other):
19434 
    return not (self == other)
4008 mandeep.dh 19435 
 
19436 
class getTransactionsRequiringExtraProcessing_args:
19437 
  """
19438 
  Attributes:
19439 
   - category
19440 
  """
19441 
 
19442 
  thrift_spec = (
19443 
    None, # 0
19444 
    (1, TType.I32, 'category', None, None, ), # 1
19445 
  )
19446 
 
19447 
  def __init__(self, category=None,):
19448 
    self.category = category
19449 
 
19450 
  def read(self, iprot):
19451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19453 
      return
19454 
    iprot.readStructBegin()
19455 
    while True:
19456 
      (fname, ftype, fid) = iprot.readFieldBegin()
19457 
      if ftype == TType.STOP:
19458 
        break
19459 
      if fid == 1:
19460 
        if ftype == TType.I32:
19461 
          self.category = iprot.readI32();
19462 
        else:
19463 
          iprot.skip(ftype)
19464 
      else:
19465 
        iprot.skip(ftype)
19466 
      iprot.readFieldEnd()
19467 
    iprot.readStructEnd()
19468 
 
19469 
  def write(self, oprot):
19470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19472 
      return
19473 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19474 
    if self.category is not None:
19475 
      oprot.writeFieldBegin('category', TType.I32, 1)
19476 
      oprot.writeI32(self.category)
19477 
      oprot.writeFieldEnd()
19478 
    oprot.writeFieldStop()
19479 
    oprot.writeStructEnd()
19480 
 
19481 
  def validate(self):
19482 
    return
19483 
 
19484 
 
19485 
  def __repr__(self):
19486 
    L = ['%s=%r' % (key, value)
19487 
      for key, value in self.__dict__.iteritems()]
19488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19489 
 
19490 
  def __eq__(self, other):
19491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19492 
 
19493 
  def __ne__(self, other):
19494 
    return not (self == other)
19495 
 
19496 
class getTransactionsRequiringExtraProcessing_result:
19497 
  """
19498 
  Attributes:
19499 
   - success
19500 
  """
19501 
 
19502 
  thrift_spec = (
19503 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19504 
  )
19505 
 
19506 
  def __init__(self, success=None,):
19507 
    self.success = success
19508 
 
19509 
  def read(self, iprot):
19510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19512 
      return
19513 
    iprot.readStructBegin()
19514 
    while True:
19515 
      (fname, ftype, fid) = iprot.readFieldBegin()
19516 
      if ftype == TType.STOP:
19517 
        break
19518 
      if fid == 0:
19519 
        if ftype == TType.LIST:
19520 
          self.success = []
6031 rajveer 19521 
          (_etype431, _size428) = iprot.readListBegin()
19522 
          for _i432 in xrange(_size428):
19523 
            _elem433 = iprot.readI64();
19524 
            self.success.append(_elem433)
4008 mandeep.dh 19525 
          iprot.readListEnd()
19526 
        else:
19527 
          iprot.skip(ftype)
19528 
      else:
19529 
        iprot.skip(ftype)
19530 
      iprot.readFieldEnd()
19531 
    iprot.readStructEnd()
19532 
 
19533 
  def write(self, oprot):
19534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19536 
      return
19537 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19538 
    if self.success is not None:
19539 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19540 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 19541 
      for iter434 in self.success:
19542 
        oprot.writeI64(iter434)
4008 mandeep.dh 19543 
      oprot.writeListEnd()
19544 
      oprot.writeFieldEnd()
19545 
    oprot.writeFieldStop()
19546 
    oprot.writeStructEnd()
19547 
 
19548 
  def validate(self):
19549 
    return
19550 
 
19551 
 
19552 
  def __repr__(self):
19553 
    L = ['%s=%r' % (key, value)
19554 
      for key, value in self.__dict__.iteritems()]
19555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19556 
 
19557 
  def __eq__(self, other):
19558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19559 
 
19560 
  def __ne__(self, other):
19561 
    return not (self == other)
19562 
 
19563 
class markTransactionAsProcessed_args:
19564 
  """
19565 
  Attributes:
19566 
   - transactionId
19567 
   - category
19568 
  """
19569 
 
19570 
  thrift_spec = (
19571 
    None, # 0
19572 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19573 
    (2, TType.I32, 'category', None, None, ), # 2
19574 
  )
19575 
 
19576 
  def __init__(self, transactionId=None, category=None,):
19577 
    self.transactionId = transactionId
19578 
    self.category = category
19579 
 
19580 
  def read(self, iprot):
19581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19583 
      return
19584 
    iprot.readStructBegin()
19585 
    while True:
19586 
      (fname, ftype, fid) = iprot.readFieldBegin()
19587 
      if ftype == TType.STOP:
19588 
        break
19589 
      if fid == 1:
19590 
        if ftype == TType.I64:
19591 
          self.transactionId = iprot.readI64();
19592 
        else:
19593 
          iprot.skip(ftype)
19594 
      elif fid == 2:
19595 
        if ftype == TType.I32:
19596 
          self.category = iprot.readI32();
19597 
        else:
19598 
          iprot.skip(ftype)
19599 
      else:
19600 
        iprot.skip(ftype)
19601 
      iprot.readFieldEnd()
19602 
    iprot.readStructEnd()
19603 
 
19604 
  def write(self, oprot):
19605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19607 
      return
19608 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19609 
    if self.transactionId is not None:
19610 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19611 
      oprot.writeI64(self.transactionId)
19612 
      oprot.writeFieldEnd()
19613 
    if self.category is not None:
19614 
      oprot.writeFieldBegin('category', TType.I32, 2)
19615 
      oprot.writeI32(self.category)
19616 
      oprot.writeFieldEnd()
19617 
    oprot.writeFieldStop()
19618 
    oprot.writeStructEnd()
19619 
 
19620 
  def validate(self):
19621 
    return
19622 
 
19623 
 
19624 
  def __repr__(self):
19625 
    L = ['%s=%r' % (key, value)
19626 
      for key, value in self.__dict__.iteritems()]
19627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19628 
 
19629 
  def __eq__(self, other):
19630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19631 
 
19632 
  def __ne__(self, other):
19633 
    return not (self == other)
19634 
 
19635 
class markTransactionAsProcessed_result:
19636 
 
19637 
  thrift_spec = (
19638 
  )
19639 
 
19640 
  def read(self, iprot):
19641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19643 
      return
19644 
    iprot.readStructBegin()
19645 
    while True:
19646 
      (fname, ftype, fid) = iprot.readFieldBegin()
19647 
      if ftype == TType.STOP:
19648 
        break
19649 
      else:
19650 
        iprot.skip(ftype)
19651 
      iprot.readFieldEnd()
19652 
    iprot.readStructEnd()
19653 
 
19654 
  def write(self, oprot):
19655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19657 
      return
19658 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19659 
    oprot.writeFieldStop()
19660 
    oprot.writeStructEnd()
19661 
 
19662 
  def validate(self):
19663 
    return
19664 
 
19665 
 
19666 
  def __repr__(self):
19667 
    L = ['%s=%r' % (key, value)
19668 
      for key, value in self.__dict__.iteritems()]
19669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19670 
 
19671 
  def __eq__(self, other):
19672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19673 
 
19674 
  def __ne__(self, other):
19675 
    return not (self == other)
4018 chandransh 19676 
 
19677 
class getItemWiseRiskyOrdersCount_args:
19678 
 
19679 
  thrift_spec = (
19680 
  )
19681 
 
19682 
  def read(self, iprot):
19683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19685 
      return
19686 
    iprot.readStructBegin()
19687 
    while True:
19688 
      (fname, ftype, fid) = iprot.readFieldBegin()
19689 
      if ftype == TType.STOP:
19690 
        break
19691 
      else:
19692 
        iprot.skip(ftype)
19693 
      iprot.readFieldEnd()
19694 
    iprot.readStructEnd()
19695 
 
19696 
  def write(self, oprot):
19697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19699 
      return
19700 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19701 
    oprot.writeFieldStop()
19702 
    oprot.writeStructEnd()
19703 
 
19704 
  def validate(self):
19705 
    return
19706 
 
19707 
 
19708 
  def __repr__(self):
19709 
    L = ['%s=%r' % (key, value)
19710 
      for key, value in self.__dict__.iteritems()]
19711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19712 
 
19713 
  def __eq__(self, other):
19714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19715 
 
19716 
  def __ne__(self, other):
19717 
    return not (self == other)
19718 
 
19719 
class getItemWiseRiskyOrdersCount_result:
19720 
  """
19721 
  Attributes:
19722 
   - success
19723 
  """
19724 
 
19725 
  thrift_spec = (
19726 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19727 
  )
19728 
 
19729 
  def __init__(self, success=None,):
19730 
    self.success = success
19731 
 
19732 
  def read(self, iprot):
19733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19735 
      return
19736 
    iprot.readStructBegin()
19737 
    while True:
19738 
      (fname, ftype, fid) = iprot.readFieldBegin()
19739 
      if ftype == TType.STOP:
19740 
        break
19741 
      if fid == 0:
19742 
        if ftype == TType.MAP:
19743 
          self.success = {}
6031 rajveer 19744 
          (_ktype436, _vtype437, _size435 ) = iprot.readMapBegin()
19745 
          for _i439 in xrange(_size435):
19746 
            _key440 = iprot.readI64();
19747 
            _val441 = iprot.readI64();
19748 
            self.success[_key440] = _val441
4018 chandransh 19749 
          iprot.readMapEnd()
19750 
        else:
19751 
          iprot.skip(ftype)
19752 
      else:
19753 
        iprot.skip(ftype)
19754 
      iprot.readFieldEnd()
19755 
    iprot.readStructEnd()
19756 
 
19757 
  def write(self, oprot):
19758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19760 
      return
19761 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
19762 
    if self.success is not None:
19763 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19764 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 19765 
      for kiter442,viter443 in self.success.items():
19766 
        oprot.writeI64(kiter442)
19767 
        oprot.writeI64(viter443)
4018 chandransh 19768 
      oprot.writeMapEnd()
19769 
      oprot.writeFieldEnd()
19770 
    oprot.writeFieldStop()
19771 
    oprot.writeStructEnd()
19772 
 
19773 
  def validate(self):
19774 
    return
19775 
 
19776 
 
19777 
  def __repr__(self):
19778 
    L = ['%s=%r' % (key, value)
19779 
      for key, value in self.__dict__.iteritems()]
19780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19781 
 
19782 
  def __eq__(self, other):
19783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19784 
 
19785 
  def __ne__(self, other):
19786 
    return not (self == other)
4247 rajveer 19787 
 
4295 varun.gupt 19788 
class getOrdersForItemIds_args:
19789 
  """
19790 
  Attributes:
19791 
   - itemIds
19792 
  """
19793 
 
19794 
  thrift_spec = (
19795 
    None, # 0
19796 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
19797 
  )
19798 
 
19799 
  def __init__(self, itemIds=None,):
19800 
    self.itemIds = itemIds
19801 
 
19802 
  def read(self, iprot):
19803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19805 
      return
19806 
    iprot.readStructBegin()
19807 
    while True:
19808 
      (fname, ftype, fid) = iprot.readFieldBegin()
19809 
      if ftype == TType.STOP:
19810 
        break
19811 
      if fid == 1:
19812 
        if ftype == TType.LIST:
19813 
          self.itemIds = []
6031 rajveer 19814 
          (_etype447, _size444) = iprot.readListBegin()
19815 
          for _i448 in xrange(_size444):
19816 
            _elem449 = iprot.readI64();
19817 
            self.itemIds.append(_elem449)
4295 varun.gupt 19818 
          iprot.readListEnd()
19819 
        else:
19820 
          iprot.skip(ftype)
19821 
      else:
19822 
        iprot.skip(ftype)
19823 
      iprot.readFieldEnd()
19824 
    iprot.readStructEnd()
19825 
 
19826 
  def write(self, oprot):
19827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19829 
      return
19830 
    oprot.writeStructBegin('getOrdersForItemIds_args')
19831 
    if self.itemIds is not None:
19832 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
19833 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6031 rajveer 19834 
      for iter450 in self.itemIds:
19835 
        oprot.writeI64(iter450)
4295 varun.gupt 19836 
      oprot.writeListEnd()
19837 
      oprot.writeFieldEnd()
19838 
    oprot.writeFieldStop()
19839 
    oprot.writeStructEnd()
19840 
 
19841 
  def validate(self):
19842 
    return
19843 
 
19844 
 
19845 
  def __repr__(self):
19846 
    L = ['%s=%r' % (key, value)
19847 
      for key, value in self.__dict__.iteritems()]
19848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19849 
 
19850 
  def __eq__(self, other):
19851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19852 
 
19853 
  def __ne__(self, other):
19854 
    return not (self == other)
19855 
 
19856 
class getOrdersForItemIds_result:
19857 
  """
19858 
  Attributes:
19859 
   - success
19860 
  """
19861 
 
19862 
  thrift_spec = (
19863 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
19864 
  )
19865 
 
19866 
  def __init__(self, success=None,):
19867 
    self.success = success
19868 
 
19869 
  def read(self, iprot):
19870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19872 
      return
19873 
    iprot.readStructBegin()
19874 
    while True:
19875 
      (fname, ftype, fid) = iprot.readFieldBegin()
19876 
      if ftype == TType.STOP:
19877 
        break
19878 
      if fid == 0:
19879 
        if ftype == TType.LIST:
19880 
          self.success = []
6031 rajveer 19881 
          (_etype454, _size451) = iprot.readListBegin()
19882 
          for _i455 in xrange(_size451):
19883 
            _elem456 = Order()
19884 
            _elem456.read(iprot)
19885 
            self.success.append(_elem456)
4295 varun.gupt 19886 
          iprot.readListEnd()
19887 
        else:
19888 
          iprot.skip(ftype)
19889 
      else:
19890 
        iprot.skip(ftype)
19891 
      iprot.readFieldEnd()
19892 
    iprot.readStructEnd()
19893 
 
19894 
  def write(self, oprot):
19895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19897 
      return
19898 
    oprot.writeStructBegin('getOrdersForItemIds_result')
19899 
    if self.success is not None:
19900 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19901 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 19902 
      for iter457 in self.success:
19903 
        iter457.write(oprot)
4295 varun.gupt 19904 
      oprot.writeListEnd()
19905 
      oprot.writeFieldEnd()
19906 
    oprot.writeFieldStop()
19907 
    oprot.writeStructEnd()
19908 
 
19909 
  def validate(self):
19910 
    return
19911 
 
19912 
 
19913 
  def __repr__(self):
19914 
    L = ['%s=%r' % (key, value)
19915 
      for key, value in self.__dict__.iteritems()]
19916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19917 
 
19918 
  def __eq__(self, other):
19919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19920 
 
19921 
  def __ne__(self, other):
19922 
    return not (self == other)
19923 
 
4247 rajveer 19924 
class markOrderCancellationRequestReceived_args:
19925 
  """
19926 
  Attributes:
19927 
   - orderId
19928 
  """
19929 
 
19930 
  thrift_spec = (
19931 
    None, # 0
19932 
    (1, TType.I64, 'orderId', None, None, ), # 1
19933 
  )
19934 
 
19935 
  def __init__(self, orderId=None,):
19936 
    self.orderId = orderId
19937 
 
19938 
  def read(self, iprot):
19939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19941 
      return
19942 
    iprot.readStructBegin()
19943 
    while True:
19944 
      (fname, ftype, fid) = iprot.readFieldBegin()
19945 
      if ftype == TType.STOP:
19946 
        break
19947 
      if fid == 1:
19948 
        if ftype == TType.I64:
19949 
          self.orderId = iprot.readI64();
19950 
        else:
19951 
          iprot.skip(ftype)
19952 
      else:
19953 
        iprot.skip(ftype)
19954 
      iprot.readFieldEnd()
19955 
    iprot.readStructEnd()
19956 
 
19957 
  def write(self, oprot):
19958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19960 
      return
19961 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
19962 
    if self.orderId is not None:
19963 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19964 
      oprot.writeI64(self.orderId)
19965 
      oprot.writeFieldEnd()
19966 
    oprot.writeFieldStop()
19967 
    oprot.writeStructEnd()
19968 
 
19969 
  def validate(self):
19970 
    return
19971 
 
19972 
 
19973 
  def __repr__(self):
19974 
    L = ['%s=%r' % (key, value)
19975 
      for key, value in self.__dict__.iteritems()]
19976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19977 
 
19978 
  def __eq__(self, other):
19979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19980 
 
19981 
  def __ne__(self, other):
19982 
    return not (self == other)
19983 
 
19984 
class markOrderCancellationRequestReceived_result:
19985 
  """
19986 
  Attributes:
19987 
   - ex
19988 
  """
19989 
 
19990 
  thrift_spec = (
19991 
    None, # 0
19992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19993 
  )
19994 
 
19995 
  def __init__(self, ex=None,):
19996 
    self.ex = ex
19997 
 
19998 
  def read(self, iprot):
19999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20001 
      return
20002 
    iprot.readStructBegin()
20003 
    while True:
20004 
      (fname, ftype, fid) = iprot.readFieldBegin()
20005 
      if ftype == TType.STOP:
20006 
        break
20007 
      if fid == 1:
20008 
        if ftype == TType.STRUCT:
20009 
          self.ex = TransactionServiceException()
20010 
          self.ex.read(iprot)
20011 
        else:
20012 
          iprot.skip(ftype)
20013 
      else:
20014 
        iprot.skip(ftype)
20015 
      iprot.readFieldEnd()
20016 
    iprot.readStructEnd()
20017 
 
20018 
  def write(self, oprot):
20019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20021 
      return
20022 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20023 
    if self.ex is not None:
20024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20025 
      self.ex.write(oprot)
20026 
      oprot.writeFieldEnd()
20027 
    oprot.writeFieldStop()
20028 
    oprot.writeStructEnd()
20029 
 
20030 
  def validate(self):
20031 
    return
20032 
 
20033 
 
20034 
  def __repr__(self):
20035 
    L = ['%s=%r' % (key, value)
20036 
      for key, value in self.__dict__.iteritems()]
20037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20038 
 
20039 
  def __eq__(self, other):
20040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20041 
 
20042 
  def __ne__(self, other):
20043 
    return not (self == other)
20044 
 
20045 
class markOrderCancellationRequestConfirmed_args:
20046 
  """
20047 
  Attributes:
20048 
   - orderId
20049 
  """
20050 
 
20051 
  thrift_spec = (
20052 
    None, # 0
20053 
    (1, TType.I64, 'orderId', None, None, ), # 1
20054 
  )
20055 
 
20056 
  def __init__(self, orderId=None,):
20057 
    self.orderId = orderId
20058 
 
20059 
  def read(self, iprot):
20060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20062 
      return
20063 
    iprot.readStructBegin()
20064 
    while True:
20065 
      (fname, ftype, fid) = iprot.readFieldBegin()
20066 
      if ftype == TType.STOP:
20067 
        break
20068 
      if fid == 1:
20069 
        if ftype == TType.I64:
20070 
          self.orderId = iprot.readI64();
20071 
        else:
20072 
          iprot.skip(ftype)
20073 
      else:
20074 
        iprot.skip(ftype)
20075 
      iprot.readFieldEnd()
20076 
    iprot.readStructEnd()
20077 
 
20078 
  def write(self, oprot):
20079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20081 
      return
20082 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20083 
    if self.orderId is not None:
20084 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20085 
      oprot.writeI64(self.orderId)
20086 
      oprot.writeFieldEnd()
20087 
    oprot.writeFieldStop()
20088 
    oprot.writeStructEnd()
20089 
 
20090 
  def validate(self):
20091 
    return
20092 
 
20093 
 
20094 
  def __repr__(self):
20095 
    L = ['%s=%r' % (key, value)
20096 
      for key, value in self.__dict__.iteritems()]
20097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20098 
 
20099 
  def __eq__(self, other):
20100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20101 
 
20102 
  def __ne__(self, other):
20103 
    return not (self == other)
20104 
 
20105 
class markOrderCancellationRequestConfirmed_result:
20106 
  """
20107 
  Attributes:
20108 
   - ex
20109 
  """
20110 
 
20111 
  thrift_spec = (
20112 
    None, # 0
20113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20114 
  )
20115 
 
20116 
  def __init__(self, ex=None,):
20117 
    self.ex = ex
20118 
 
20119 
  def read(self, iprot):
20120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20122 
      return
20123 
    iprot.readStructBegin()
20124 
    while True:
20125 
      (fname, ftype, fid) = iprot.readFieldBegin()
20126 
      if ftype == TType.STOP:
20127 
        break
20128 
      if fid == 1:
20129 
        if ftype == TType.STRUCT:
20130 
          self.ex = TransactionServiceException()
20131 
          self.ex.read(iprot)
20132 
        else:
20133 
          iprot.skip(ftype)
20134 
      else:
20135 
        iprot.skip(ftype)
20136 
      iprot.readFieldEnd()
20137 
    iprot.readStructEnd()
20138 
 
20139 
  def write(self, oprot):
20140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20142 
      return
20143 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20144 
    if self.ex is not None:
20145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20146 
      self.ex.write(oprot)
20147 
      oprot.writeFieldEnd()
20148 
    oprot.writeFieldStop()
20149 
    oprot.writeStructEnd()
20150 
 
20151 
  def validate(self):
20152 
    return
20153 
 
20154 
 
20155 
  def __repr__(self):
20156 
    L = ['%s=%r' % (key, value)
20157 
      for key, value in self.__dict__.iteritems()]
20158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20159 
 
20160 
  def __eq__(self, other):
20161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20162 
 
20163 
  def __ne__(self, other):
20164 
    return not (self == other)
20165 
 
20166 
class markOrderCancellationRequestDenied_args:
20167 
  """
20168 
  Attributes:
20169 
   - orderId
20170 
  """
20171 
 
20172 
  thrift_spec = (
20173 
    None, # 0
20174 
    (1, TType.I64, 'orderId', None, None, ), # 1
20175 
  )
20176 
 
20177 
  def __init__(self, orderId=None,):
20178 
    self.orderId = orderId
20179 
 
20180 
  def read(self, iprot):
20181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20183 
      return
20184 
    iprot.readStructBegin()
20185 
    while True:
20186 
      (fname, ftype, fid) = iprot.readFieldBegin()
20187 
      if ftype == TType.STOP:
20188 
        break
20189 
      if fid == 1:
20190 
        if ftype == TType.I64:
20191 
          self.orderId = iprot.readI64();
20192 
        else:
20193 
          iprot.skip(ftype)
20194 
      else:
20195 
        iprot.skip(ftype)
20196 
      iprot.readFieldEnd()
20197 
    iprot.readStructEnd()
20198 
 
20199 
  def write(self, oprot):
20200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20202 
      return
20203 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20204 
    if self.orderId is not None:
20205 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20206 
      oprot.writeI64(self.orderId)
20207 
      oprot.writeFieldEnd()
20208 
    oprot.writeFieldStop()
20209 
    oprot.writeStructEnd()
20210 
 
20211 
  def validate(self):
20212 
    return
20213 
 
20214 
 
20215 
  def __repr__(self):
20216 
    L = ['%s=%r' % (key, value)
20217 
      for key, value in self.__dict__.iteritems()]
20218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20219 
 
20220 
  def __eq__(self, other):
20221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20222 
 
20223 
  def __ne__(self, other):
20224 
    return not (self == other)
20225 
 
20226 
class markOrderCancellationRequestDenied_result:
20227 
  """
20228 
  Attributes:
20229 
   - ex
20230 
  """
20231 
 
20232 
  thrift_spec = (
20233 
    None, # 0
20234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20235 
  )
20236 
 
20237 
  def __init__(self, ex=None,):
20238 
    self.ex = ex
20239 
 
20240 
  def read(self, iprot):
20241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20243 
      return
20244 
    iprot.readStructBegin()
20245 
    while True:
20246 
      (fname, ftype, fid) = iprot.readFieldBegin()
20247 
      if ftype == TType.STOP:
20248 
        break
20249 
      if fid == 1:
20250 
        if ftype == TType.STRUCT:
20251 
          self.ex = TransactionServiceException()
20252 
          self.ex.read(iprot)
20253 
        else:
20254 
          iprot.skip(ftype)
20255 
      else:
20256 
        iprot.skip(ftype)
20257 
      iprot.readFieldEnd()
20258 
    iprot.readStructEnd()
20259 
 
20260 
  def write(self, oprot):
20261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20263 
      return
20264 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20265 
    if self.ex is not None:
20266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20267 
      self.ex.write(oprot)
20268 
      oprot.writeFieldEnd()
20269 
    oprot.writeFieldStop()
20270 
    oprot.writeStructEnd()
20271 
 
20272 
  def validate(self):
20273 
    return
20274 
 
20275 
 
20276 
  def __repr__(self):
20277 
    L = ['%s=%r' % (key, value)
20278 
      for key, value in self.__dict__.iteritems()]
20279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20280 
 
20281 
  def __eq__(self, other):
20282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20283 
 
20284 
  def __ne__(self, other):
20285 
    return not (self == other)
20286 
 
4258 rajveer 20287 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20288 
  """
20289 
  Attributes:
4258 rajveer 20290 
   - transactionId
4247 rajveer 20291 
  """
20292 
 
20293 
  thrift_spec = (
20294 
    None, # 0
4258 rajveer 20295 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20296 
  )
20297 
 
4258 rajveer 20298 
  def __init__(self, transactionId=None,):
20299 
    self.transactionId = transactionId
4247 rajveer 20300 
 
20301 
  def read(self, iprot):
20302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20304 
      return
20305 
    iprot.readStructBegin()
20306 
    while True:
20307 
      (fname, ftype, fid) = iprot.readFieldBegin()
20308 
      if ftype == TType.STOP:
20309 
        break
20310 
      if fid == 1:
20311 
        if ftype == TType.I64:
4258 rajveer 20312 
          self.transactionId = iprot.readI64();
4247 rajveer 20313 
        else:
20314 
          iprot.skip(ftype)
20315 
      else:
20316 
        iprot.skip(ftype)
20317 
      iprot.readFieldEnd()
20318 
    iprot.readStructEnd()
20319 
 
20320 
  def write(self, oprot):
20321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20323 
      return
4258 rajveer 20324 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20325 
    if self.transactionId is not None:
20326 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20327 
      oprot.writeI64(self.transactionId)
4247 rajveer 20328 
      oprot.writeFieldEnd()
20329 
    oprot.writeFieldStop()
20330 
    oprot.writeStructEnd()
20331 
 
20332 
  def validate(self):
20333 
    return
20334 
 
20335 
 
20336 
  def __repr__(self):
20337 
    L = ['%s=%r' % (key, value)
20338 
      for key, value in self.__dict__.iteritems()]
20339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20340 
 
20341 
  def __eq__(self, other):
20342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20343 
 
20344 
  def __ne__(self, other):
20345 
    return not (self == other)
20346 
 
4258 rajveer 20347 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20348 
  """
20349 
  Attributes:
20350 
   - ex
20351 
  """
20352 
 
20353 
  thrift_spec = (
20354 
    None, # 0
20355 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20356 
  )
20357 
 
20358 
  def __init__(self, ex=None,):
20359 
    self.ex = ex
20360 
 
20361 
  def read(self, iprot):
20362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20364 
      return
20365 
    iprot.readStructBegin()
20366 
    while True:
20367 
      (fname, ftype, fid) = iprot.readFieldBegin()
20368 
      if ftype == TType.STOP:
20369 
        break
20370 
      if fid == 1:
20371 
        if ftype == TType.STRUCT:
20372 
          self.ex = TransactionServiceException()
20373 
          self.ex.read(iprot)
20374 
        else:
20375 
          iprot.skip(ftype)
20376 
      else:
20377 
        iprot.skip(ftype)
20378 
      iprot.readFieldEnd()
20379 
    iprot.readStructEnd()
20380 
 
20381 
  def write(self, oprot):
20382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20384 
      return
4258 rajveer 20385 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20386 
    if self.ex is not None:
20387 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20388 
      self.ex.write(oprot)
20389 
      oprot.writeFieldEnd()
20390 
    oprot.writeFieldStop()
20391 
    oprot.writeStructEnd()
20392 
 
20393 
  def validate(self):
20394 
    return
20395 
 
20396 
 
20397 
  def __repr__(self):
20398 
    L = ['%s=%r' % (key, value)
20399 
      for key, value in self.__dict__.iteritems()]
20400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20401 
 
20402 
  def __eq__(self, other):
20403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20404 
 
20405 
  def __ne__(self, other):
20406 
    return not (self == other)
4259 anupam.sin 20407 
 
20408 
class refundTransaction_args:
20409 
  """
20410 
  Attributes:
20411 
   - transactionId
20412 
   - refundedBy
20413 
   - reason
20414 
  """
20415 
 
20416 
  thrift_spec = (
20417 
    None, # 0
20418 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20419 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20420 
    (3, TType.STRING, 'reason', None, None, ), # 3
20421 
  )
20422 
 
20423 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20424 
    self.transactionId = transactionId
20425 
    self.refundedBy = refundedBy
20426 
    self.reason = reason
20427 
 
20428 
  def read(self, iprot):
20429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20431 
      return
20432 
    iprot.readStructBegin()
20433 
    while True:
20434 
      (fname, ftype, fid) = iprot.readFieldBegin()
20435 
      if ftype == TType.STOP:
20436 
        break
20437 
      if fid == 1:
20438 
        if ftype == TType.I64:
20439 
          self.transactionId = iprot.readI64();
20440 
        else:
20441 
          iprot.skip(ftype)
20442 
      elif fid == 2:
20443 
        if ftype == TType.STRING:
20444 
          self.refundedBy = iprot.readString();
20445 
        else:
20446 
          iprot.skip(ftype)
20447 
      elif fid == 3:
20448 
        if ftype == TType.STRING:
20449 
          self.reason = iprot.readString();
20450 
        else:
20451 
          iprot.skip(ftype)
20452 
      else:
20453 
        iprot.skip(ftype)
20454 
      iprot.readFieldEnd()
20455 
    iprot.readStructEnd()
20456 
 
20457 
  def write(self, oprot):
20458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20460 
      return
20461 
    oprot.writeStructBegin('refundTransaction_args')
20462 
    if self.transactionId is not None:
20463 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20464 
      oprot.writeI64(self.transactionId)
20465 
      oprot.writeFieldEnd()
20466 
    if self.refundedBy is not None:
20467 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20468 
      oprot.writeString(self.refundedBy)
20469 
      oprot.writeFieldEnd()
20470 
    if self.reason is not None:
20471 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20472 
      oprot.writeString(self.reason)
20473 
      oprot.writeFieldEnd()
20474 
    oprot.writeFieldStop()
20475 
    oprot.writeStructEnd()
20476 
 
20477 
  def validate(self):
20478 
    return
20479 
 
20480 
 
20481 
  def __repr__(self):
20482 
    L = ['%s=%r' % (key, value)
20483 
      for key, value in self.__dict__.iteritems()]
20484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20485 
 
20486 
  def __eq__(self, other):
20487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20488 
 
20489 
  def __ne__(self, other):
20490 
    return not (self == other)
20491 
 
20492 
class refundTransaction_result:
20493 
  """
20494 
  Attributes:
20495 
   - ex
20496 
  """
20497 
 
20498 
  thrift_spec = (
20499 
    None, # 0
20500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20501 
  )
20502 
 
20503 
  def __init__(self, ex=None,):
20504 
    self.ex = ex
20505 
 
20506 
  def read(self, iprot):
20507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20509 
      return
20510 
    iprot.readStructBegin()
20511 
    while True:
20512 
      (fname, ftype, fid) = iprot.readFieldBegin()
20513 
      if ftype == TType.STOP:
20514 
        break
20515 
      if fid == 1:
20516 
        if ftype == TType.STRUCT:
20517 
          self.ex = TransactionServiceException()
20518 
          self.ex.read(iprot)
20519 
        else:
20520 
          iprot.skip(ftype)
20521 
      else:
20522 
        iprot.skip(ftype)
20523 
      iprot.readFieldEnd()
20524 
    iprot.readStructEnd()
20525 
 
20526 
  def write(self, oprot):
20527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20529 
      return
20530 
    oprot.writeStructBegin('refundTransaction_result')
20531 
    if self.ex is not None:
20532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20533 
      self.ex.write(oprot)
20534 
      oprot.writeFieldEnd()
20535 
    oprot.writeFieldStop()
20536 
    oprot.writeStructEnd()
20537 
 
20538 
  def validate(self):
20539 
    return
20540 
 
20541 
 
20542 
  def __repr__(self):
20543 
    L = ['%s=%r' % (key, value)
20544 
      for key, value in self.__dict__.iteritems()]
20545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20546 
 
20547 
  def __eq__(self, other):
20548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20549 
 
20550 
  def __ne__(self, other):
20551 
    return not (self == other)
4285 rajveer 20552 
 
4324 mandeep.dh 20553 
class updateShipmentAddress_args:
20554 
  """
20555 
  Attributes:
20556 
   - orderId
20557 
   - addressId
20558 
  """
20559 
 
20560 
  thrift_spec = (
20561 
    None, # 0
20562 
    (1, TType.I64, 'orderId', None, None, ), # 1
20563 
    (2, TType.I64, 'addressId', None, None, ), # 2
20564 
  )
20565 
 
20566 
  def __init__(self, orderId=None, addressId=None,):
20567 
    self.orderId = orderId
20568 
    self.addressId = addressId
20569 
 
20570 
  def read(self, iprot):
20571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20573 
      return
20574 
    iprot.readStructBegin()
20575 
    while True:
20576 
      (fname, ftype, fid) = iprot.readFieldBegin()
20577 
      if ftype == TType.STOP:
20578 
        break
20579 
      if fid == 1:
20580 
        if ftype == TType.I64:
20581 
          self.orderId = iprot.readI64();
20582 
        else:
20583 
          iprot.skip(ftype)
20584 
      elif fid == 2:
20585 
        if ftype == TType.I64:
20586 
          self.addressId = iprot.readI64();
20587 
        else:
20588 
          iprot.skip(ftype)
20589 
      else:
20590 
        iprot.skip(ftype)
20591 
      iprot.readFieldEnd()
20592 
    iprot.readStructEnd()
20593 
 
20594 
  def write(self, oprot):
20595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20597 
      return
20598 
    oprot.writeStructBegin('updateShipmentAddress_args')
20599 
    if self.orderId is not None:
20600 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20601 
      oprot.writeI64(self.orderId)
20602 
      oprot.writeFieldEnd()
20603 
    if self.addressId is not None:
20604 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20605 
      oprot.writeI64(self.addressId)
20606 
      oprot.writeFieldEnd()
20607 
    oprot.writeFieldStop()
20608 
    oprot.writeStructEnd()
20609 
 
20610 
  def validate(self):
20611 
    return
20612 
 
20613 
 
20614 
  def __repr__(self):
20615 
    L = ['%s=%r' % (key, value)
20616 
      for key, value in self.__dict__.iteritems()]
20617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20618 
 
20619 
  def __eq__(self, other):
20620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20621 
 
20622 
  def __ne__(self, other):
20623 
    return not (self == other)
20624 
 
20625 
class updateShipmentAddress_result:
20626 
  """
20627 
  Attributes:
20628 
   - ex
20629 
  """
20630 
 
20631 
  thrift_spec = (
20632 
    None, # 0
20633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20634 
  )
20635 
 
20636 
  def __init__(self, ex=None,):
20637 
    self.ex = ex
20638 
 
20639 
  def read(self, iprot):
20640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20642 
      return
20643 
    iprot.readStructBegin()
20644 
    while True:
20645 
      (fname, ftype, fid) = iprot.readFieldBegin()
20646 
      if ftype == TType.STOP:
20647 
        break
20648 
      if fid == 1:
20649 
        if ftype == TType.STRUCT:
20650 
          self.ex = TransactionServiceException()
20651 
          self.ex.read(iprot)
20652 
        else:
20653 
          iprot.skip(ftype)
20654 
      else:
20655 
        iprot.skip(ftype)
20656 
      iprot.readFieldEnd()
20657 
    iprot.readStructEnd()
20658 
 
20659 
  def write(self, oprot):
20660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20662 
      return
20663 
    oprot.writeStructBegin('updateShipmentAddress_result')
20664 
    if self.ex is not None:
20665 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20666 
      self.ex.write(oprot)
20667 
      oprot.writeFieldEnd()
20668 
    oprot.writeFieldStop()
20669 
    oprot.writeStructEnd()
20670 
 
20671 
  def validate(self):
20672 
    return
20673 
 
20674 
 
20675 
  def __repr__(self):
20676 
    L = ['%s=%r' % (key, value)
20677 
      for key, value in self.__dict__.iteritems()]
20678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20679 
 
20680 
  def __eq__(self, other):
20681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20682 
 
20683 
  def __ne__(self, other):
20684 
    return not (self == other)
20685 
 
4285 rajveer 20686 
class acceptOrdersForItemId_args:
20687 
  """
20688 
  Attributes:
20689 
   - itemId
20690 
   - inventory
20691 
  """
20692 
 
20693 
  thrift_spec = (
20694 
    None, # 0
20695 
    (1, TType.I64, 'itemId', None, None, ), # 1
20696 
    (2, TType.I64, 'inventory', None, None, ), # 2
20697 
  )
20698 
 
20699 
  def __init__(self, itemId=None, inventory=None,):
20700 
    self.itemId = itemId
20701 
    self.inventory = inventory
20702 
 
20703 
  def read(self, iprot):
20704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20706 
      return
20707 
    iprot.readStructBegin()
20708 
    while True:
20709 
      (fname, ftype, fid) = iprot.readFieldBegin()
20710 
      if ftype == TType.STOP:
20711 
        break
20712 
      if fid == 1:
20713 
        if ftype == TType.I64:
20714 
          self.itemId = iprot.readI64();
20715 
        else:
20716 
          iprot.skip(ftype)
20717 
      elif fid == 2:
20718 
        if ftype == TType.I64:
20719 
          self.inventory = iprot.readI64();
20720 
        else:
20721 
          iprot.skip(ftype)
20722 
      else:
20723 
        iprot.skip(ftype)
20724 
      iprot.readFieldEnd()
20725 
    iprot.readStructEnd()
20726 
 
20727 
  def write(self, oprot):
20728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20730 
      return
20731 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20732 
    if self.itemId is not None:
20733 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20734 
      oprot.writeI64(self.itemId)
20735 
      oprot.writeFieldEnd()
20736 
    if self.inventory is not None:
20737 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20738 
      oprot.writeI64(self.inventory)
20739 
      oprot.writeFieldEnd()
20740 
    oprot.writeFieldStop()
20741 
    oprot.writeStructEnd()
20742 
 
20743 
  def validate(self):
20744 
    return
20745 
 
20746 
 
20747 
  def __repr__(self):
20748 
    L = ['%s=%r' % (key, value)
20749 
      for key, value in self.__dict__.iteritems()]
20750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20751 
 
20752 
  def __eq__(self, other):
20753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20754 
 
20755 
  def __ne__(self, other):
20756 
    return not (self == other)
20757 
 
20758 
class acceptOrdersForItemId_result:
20759 
  """
20760 
  Attributes:
20761 
   - success
20762 
   - ex
20763 
  """
20764 
 
20765 
  thrift_spec = (
20766 
    (0, TType.BOOL, 'success', None, None, ), # 0
20767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20768 
  )
20769 
 
20770 
  def __init__(self, success=None, ex=None,):
20771 
    self.success = success
20772 
    self.ex = ex
20773 
 
20774 
  def read(self, iprot):
20775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20777 
      return
20778 
    iprot.readStructBegin()
20779 
    while True:
20780 
      (fname, ftype, fid) = iprot.readFieldBegin()
20781 
      if ftype == TType.STOP:
20782 
        break
20783 
      if fid == 0:
20784 
        if ftype == TType.BOOL:
20785 
          self.success = iprot.readBool();
20786 
        else:
20787 
          iprot.skip(ftype)
20788 
      elif fid == 1:
20789 
        if ftype == TType.STRUCT:
20790 
          self.ex = TransactionServiceException()
20791 
          self.ex.read(iprot)
20792 
        else:
20793 
          iprot.skip(ftype)
20794 
      else:
20795 
        iprot.skip(ftype)
20796 
      iprot.readFieldEnd()
20797 
    iprot.readStructEnd()
20798 
 
20799 
  def write(self, oprot):
20800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20802 
      return
20803 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
20804 
    if self.success is not None:
20805 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20806 
      oprot.writeBool(self.success)
20807 
      oprot.writeFieldEnd()
20808 
    if self.ex is not None:
20809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20810 
      self.ex.write(oprot)
20811 
      oprot.writeFieldEnd()
20812 
    oprot.writeFieldStop()
20813 
    oprot.writeStructEnd()
20814 
 
20815 
  def validate(self):
20816 
    return
20817 
 
20818 
 
20819 
  def __repr__(self):
20820 
    L = ['%s=%r' % (key, value)
20821 
      for key, value in self.__dict__.iteritems()]
20822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20823 
 
20824 
  def __eq__(self, other):
20825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20826 
 
20827 
  def __ne__(self, other):
20828 
    return not (self == other)
4303 rajveer 20829 
 
20830 
class markOrdersAsPORaised_args:
20831 
  """
20832 
  Attributes:
20833 
   - vendorId
20834 
   - itemId
20835 
   - quantity
20836 
   - estimate
4369 rajveer 20837 
   - isReminder
4303 rajveer 20838 
  """
20839 
 
20840 
  thrift_spec = (
20841 
    None, # 0
20842 
    (1, TType.I64, 'vendorId', None, None, ), # 1
20843 
    (2, TType.I64, 'itemId', None, None, ), # 2
20844 
    (3, TType.I64, 'quantity', None, None, ), # 3
20845 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 20846 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 20847 
  )
20848 
 
4369 rajveer 20849 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 20850 
    self.vendorId = vendorId
20851 
    self.itemId = itemId
20852 
    self.quantity = quantity
20853 
    self.estimate = estimate
4369 rajveer 20854 
    self.isReminder = isReminder
4303 rajveer 20855 
 
20856 
  def read(self, iprot):
20857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20859 
      return
20860 
    iprot.readStructBegin()
20861 
    while True:
20862 
      (fname, ftype, fid) = iprot.readFieldBegin()
20863 
      if ftype == TType.STOP:
20864 
        break
20865 
      if fid == 1:
20866 
        if ftype == TType.I64:
20867 
          self.vendorId = iprot.readI64();
20868 
        else:
20869 
          iprot.skip(ftype)
20870 
      elif fid == 2:
20871 
        if ftype == TType.I64:
20872 
          self.itemId = iprot.readI64();
20873 
        else:
20874 
          iprot.skip(ftype)
20875 
      elif fid == 3:
20876 
        if ftype == TType.I64:
20877 
          self.quantity = iprot.readI64();
20878 
        else:
20879 
          iprot.skip(ftype)
20880 
      elif fid == 4:
20881 
        if ftype == TType.I64:
20882 
          self.estimate = iprot.readI64();
20883 
        else:
20884 
          iprot.skip(ftype)
4369 rajveer 20885 
      elif fid == 5:
20886 
        if ftype == TType.BOOL:
20887 
          self.isReminder = iprot.readBool();
20888 
        else:
20889 
          iprot.skip(ftype)
4303 rajveer 20890 
      else:
20891 
        iprot.skip(ftype)
20892 
      iprot.readFieldEnd()
20893 
    iprot.readStructEnd()
20894 
 
20895 
  def write(self, oprot):
20896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20898 
      return
20899 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
20900 
    if self.vendorId is not None:
20901 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
20902 
      oprot.writeI64(self.vendorId)
20903 
      oprot.writeFieldEnd()
20904 
    if self.itemId is not None:
20905 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20906 
      oprot.writeI64(self.itemId)
20907 
      oprot.writeFieldEnd()
20908 
    if self.quantity is not None:
20909 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
20910 
      oprot.writeI64(self.quantity)
20911 
      oprot.writeFieldEnd()
20912 
    if self.estimate is not None:
20913 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
20914 
      oprot.writeI64(self.estimate)
20915 
      oprot.writeFieldEnd()
4369 rajveer 20916 
    if self.isReminder is not None:
20917 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
20918 
      oprot.writeBool(self.isReminder)
20919 
      oprot.writeFieldEnd()
4303 rajveer 20920 
    oprot.writeFieldStop()
20921 
    oprot.writeStructEnd()
20922 
 
20923 
  def validate(self):
20924 
    return
20925 
 
20926 
 
20927 
  def __repr__(self):
20928 
    L = ['%s=%r' % (key, value)
20929 
      for key, value in self.__dict__.iteritems()]
20930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20931 
 
20932 
  def __eq__(self, other):
20933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20934 
 
20935 
  def __ne__(self, other):
20936 
    return not (self == other)
20937 
 
20938 
class markOrdersAsPORaised_result:
20939 
  """
20940 
  Attributes:
20941 
   - ex
20942 
  """
20943 
 
20944 
  thrift_spec = (
20945 
    None, # 0
20946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20947 
  )
20948 
 
20949 
  def __init__(self, ex=None,):
20950 
    self.ex = ex
20951 
 
20952 
  def read(self, iprot):
20953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20955 
      return
20956 
    iprot.readStructBegin()
20957 
    while True:
20958 
      (fname, ftype, fid) = iprot.readFieldBegin()
20959 
      if ftype == TType.STOP:
20960 
        break
20961 
      if fid == 1:
20962 
        if ftype == TType.STRUCT:
20963 
          self.ex = TransactionServiceException()
20964 
          self.ex.read(iprot)
20965 
        else:
20966 
          iprot.skip(ftype)
20967 
      else:
20968 
        iprot.skip(ftype)
20969 
      iprot.readFieldEnd()
20970 
    iprot.readStructEnd()
20971 
 
20972 
  def write(self, oprot):
20973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20975 
      return
20976 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
20977 
    if self.ex is not None:
20978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20979 
      self.ex.write(oprot)
20980 
      oprot.writeFieldEnd()
20981 
    oprot.writeFieldStop()
20982 
    oprot.writeStructEnd()
20983 
 
20984 
  def validate(self):
20985 
    return
20986 
 
20987 
 
20988 
  def __repr__(self):
20989 
    L = ['%s=%r' % (key, value)
20990 
      for key, value in self.__dict__.iteritems()]
20991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20992 
 
20993 
  def __eq__(self, other):
20994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20995 
 
20996 
  def __ne__(self, other):
20997 
    return not (self == other)
20998 
 
20999 
class markOrdersAsReversalInitiated_args:
21000 
  """
21001 
  Attributes:
21002 
   - vendorId
21003 
   - itemId
21004 
   - quantity
21005 
   - estimate
4369 rajveer 21006 
   - isReminder
4303 rajveer 21007 
  """
21008 
 
21009 
  thrift_spec = (
21010 
    None, # 0
21011 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21012 
    (2, TType.I64, 'itemId', None, None, ), # 2
21013 
    (3, TType.I64, 'quantity', None, None, ), # 3
21014 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21015 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21016 
  )
21017 
 
4369 rajveer 21018 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21019 
    self.vendorId = vendorId
21020 
    self.itemId = itemId
21021 
    self.quantity = quantity
21022 
    self.estimate = estimate
4369 rajveer 21023 
    self.isReminder = isReminder
4303 rajveer 21024 
 
21025 
  def read(self, iprot):
21026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21028 
      return
21029 
    iprot.readStructBegin()
21030 
    while True:
21031 
      (fname, ftype, fid) = iprot.readFieldBegin()
21032 
      if ftype == TType.STOP:
21033 
        break
21034 
      if fid == 1:
21035 
        if ftype == TType.I64:
21036 
          self.vendorId = iprot.readI64();
21037 
        else:
21038 
          iprot.skip(ftype)
21039 
      elif fid == 2:
21040 
        if ftype == TType.I64:
21041 
          self.itemId = iprot.readI64();
21042 
        else:
21043 
          iprot.skip(ftype)
21044 
      elif fid == 3:
21045 
        if ftype == TType.I64:
21046 
          self.quantity = iprot.readI64();
21047 
        else:
21048 
          iprot.skip(ftype)
21049 
      elif fid == 4:
21050 
        if ftype == TType.I64:
21051 
          self.estimate = iprot.readI64();
21052 
        else:
21053 
          iprot.skip(ftype)
4369 rajveer 21054 
      elif fid == 5:
21055 
        if ftype == TType.BOOL:
21056 
          self.isReminder = iprot.readBool();
21057 
        else:
21058 
          iprot.skip(ftype)
4303 rajveer 21059 
      else:
21060 
        iprot.skip(ftype)
21061 
      iprot.readFieldEnd()
21062 
    iprot.readStructEnd()
21063 
 
21064 
  def write(self, oprot):
21065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21067 
      return
21068 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21069 
    if self.vendorId is not None:
21070 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21071 
      oprot.writeI64(self.vendorId)
21072 
      oprot.writeFieldEnd()
21073 
    if self.itemId is not None:
21074 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21075 
      oprot.writeI64(self.itemId)
21076 
      oprot.writeFieldEnd()
21077 
    if self.quantity is not None:
21078 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21079 
      oprot.writeI64(self.quantity)
21080 
      oprot.writeFieldEnd()
21081 
    if self.estimate is not None:
21082 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21083 
      oprot.writeI64(self.estimate)
21084 
      oprot.writeFieldEnd()
4369 rajveer 21085 
    if self.isReminder is not None:
21086 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21087 
      oprot.writeBool(self.isReminder)
21088 
      oprot.writeFieldEnd()
4303 rajveer 21089 
    oprot.writeFieldStop()
21090 
    oprot.writeStructEnd()
21091 
 
21092 
  def validate(self):
21093 
    return
21094 
 
21095 
 
21096 
  def __repr__(self):
21097 
    L = ['%s=%r' % (key, value)
21098 
      for key, value in self.__dict__.iteritems()]
21099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21100 
 
21101 
  def __eq__(self, other):
21102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21103 
 
21104 
  def __ne__(self, other):
21105 
    return not (self == other)
21106 
 
21107 
class markOrdersAsReversalInitiated_result:
21108 
  """
21109 
  Attributes:
21110 
   - ex
21111 
  """
21112 
 
21113 
  thrift_spec = (
21114 
    None, # 0
21115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21116 
  )
21117 
 
21118 
  def __init__(self, ex=None,):
21119 
    self.ex = ex
21120 
 
21121 
  def read(self, iprot):
21122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21124 
      return
21125 
    iprot.readStructBegin()
21126 
    while True:
21127 
      (fname, ftype, fid) = iprot.readFieldBegin()
21128 
      if ftype == TType.STOP:
21129 
        break
21130 
      if fid == 1:
21131 
        if ftype == TType.STRUCT:
21132 
          self.ex = TransactionServiceException()
21133 
          self.ex.read(iprot)
21134 
        else:
21135 
          iprot.skip(ftype)
21136 
      else:
21137 
        iprot.skip(ftype)
21138 
      iprot.readFieldEnd()
21139 
    iprot.readStructEnd()
21140 
 
21141 
  def write(self, oprot):
21142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21144 
      return
21145 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21146 
    if self.ex is not None:
21147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21148 
      self.ex.write(oprot)
21149 
      oprot.writeFieldEnd()
21150 
    oprot.writeFieldStop()
21151 
    oprot.writeStructEnd()
21152 
 
21153 
  def validate(self):
21154 
    return
21155 
 
21156 
 
21157 
  def __repr__(self):
21158 
    L = ['%s=%r' % (key, value)
21159 
      for key, value in self.__dict__.iteritems()]
21160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21161 
 
21162 
  def __eq__(self, other):
21163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21164 
 
21165 
  def __ne__(self, other):
21166 
    return not (self == other)
21167 
 
21168 
class markOrdersAsNotAvailabke_args:
21169 
  """
21170 
  Attributes:
21171 
   - vendorId
21172 
   - itemId
21173 
   - quantity
21174 
   - estimate
4369 rajveer 21175 
   - isReminder
4303 rajveer 21176 
  """
21177 
 
21178 
  thrift_spec = (
21179 
    None, # 0
21180 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21181 
    (2, TType.I64, 'itemId', None, None, ), # 2
21182 
    (3, TType.I64, 'quantity', None, None, ), # 3
21183 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21184 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21185 
  )
21186 
 
4369 rajveer 21187 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21188 
    self.vendorId = vendorId
21189 
    self.itemId = itemId
21190 
    self.quantity = quantity
21191 
    self.estimate = estimate
4369 rajveer 21192 
    self.isReminder = isReminder
4303 rajveer 21193 
 
21194 
  def read(self, iprot):
21195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21197 
      return
21198 
    iprot.readStructBegin()
21199 
    while True:
21200 
      (fname, ftype, fid) = iprot.readFieldBegin()
21201 
      if ftype == TType.STOP:
21202 
        break
21203 
      if fid == 1:
21204 
        if ftype == TType.I64:
21205 
          self.vendorId = iprot.readI64();
21206 
        else:
21207 
          iprot.skip(ftype)
21208 
      elif fid == 2:
21209 
        if ftype == TType.I64:
21210 
          self.itemId = iprot.readI64();
21211 
        else:
21212 
          iprot.skip(ftype)
21213 
      elif fid == 3:
21214 
        if ftype == TType.I64:
21215 
          self.quantity = iprot.readI64();
21216 
        else:
21217 
          iprot.skip(ftype)
21218 
      elif fid == 4:
21219 
        if ftype == TType.I64:
21220 
          self.estimate = iprot.readI64();
21221 
        else:
21222 
          iprot.skip(ftype)
4369 rajveer 21223 
      elif fid == 5:
21224 
        if ftype == TType.BOOL:
21225 
          self.isReminder = iprot.readBool();
21226 
        else:
21227 
          iprot.skip(ftype)
4303 rajveer 21228 
      else:
21229 
        iprot.skip(ftype)
21230 
      iprot.readFieldEnd()
21231 
    iprot.readStructEnd()
21232 
 
21233 
  def write(self, oprot):
21234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21236 
      return
21237 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21238 
    if self.vendorId is not None:
21239 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21240 
      oprot.writeI64(self.vendorId)
21241 
      oprot.writeFieldEnd()
21242 
    if self.itemId is not None:
21243 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21244 
      oprot.writeI64(self.itemId)
21245 
      oprot.writeFieldEnd()
21246 
    if self.quantity is not None:
21247 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21248 
      oprot.writeI64(self.quantity)
21249 
      oprot.writeFieldEnd()
21250 
    if self.estimate is not None:
21251 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21252 
      oprot.writeI64(self.estimate)
21253 
      oprot.writeFieldEnd()
4369 rajveer 21254 
    if self.isReminder is not None:
21255 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21256 
      oprot.writeBool(self.isReminder)
21257 
      oprot.writeFieldEnd()
4303 rajveer 21258 
    oprot.writeFieldStop()
21259 
    oprot.writeStructEnd()
21260 
 
21261 
  def validate(self):
21262 
    return
21263 
 
21264 
 
21265 
  def __repr__(self):
21266 
    L = ['%s=%r' % (key, value)
21267 
      for key, value in self.__dict__.iteritems()]
21268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21269 
 
21270 
  def __eq__(self, other):
21271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21272 
 
21273 
  def __ne__(self, other):
21274 
    return not (self == other)
21275 
 
21276 
class markOrdersAsNotAvailabke_result:
21277 
  """
21278 
  Attributes:
21279 
   - ex
21280 
  """
21281 
 
21282 
  thrift_spec = (
21283 
    None, # 0
21284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21285 
  )
21286 
 
21287 
  def __init__(self, ex=None,):
21288 
    self.ex = ex
21289 
 
21290 
  def read(self, iprot):
21291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21293 
      return
21294 
    iprot.readStructBegin()
21295 
    while True:
21296 
      (fname, ftype, fid) = iprot.readFieldBegin()
21297 
      if ftype == TType.STOP:
21298 
        break
21299 
      if fid == 1:
21300 
        if ftype == TType.STRUCT:
21301 
          self.ex = TransactionServiceException()
21302 
          self.ex.read(iprot)
21303 
        else:
21304 
          iprot.skip(ftype)
21305 
      else:
21306 
        iprot.skip(ftype)
21307 
      iprot.readFieldEnd()
21308 
    iprot.readStructEnd()
21309 
 
21310 
  def write(self, oprot):
21311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21313 
      return
21314 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21315 
    if self.ex is not None:
21316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21317 
      self.ex.write(oprot)
21318 
      oprot.writeFieldEnd()
21319 
    oprot.writeFieldStop()
21320 
    oprot.writeStructEnd()
21321 
 
21322 
  def validate(self):
21323 
    return
21324 
 
21325 
 
21326 
  def __repr__(self):
21327 
    L = ['%s=%r' % (key, value)
21328 
      for key, value in self.__dict__.iteritems()]
21329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21330 
 
21331 
  def __eq__(self, other):
21332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21333 
 
21334 
  def __ne__(self, other):
21335 
    return not (self == other)
4369 rajveer 21336 
 
21337 
class markOrdersAsTimeout_args:
21338 
  """
21339 
  Attributes:
21340 
   - vendorId
21341 
  """
21342 
 
21343 
  thrift_spec = (
21344 
    None, # 0
21345 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21346 
  )
21347 
 
21348 
  def __init__(self, vendorId=None,):
21349 
    self.vendorId = vendorId
21350 
 
21351 
  def read(self, iprot):
21352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21354 
      return
21355 
    iprot.readStructBegin()
21356 
    while True:
21357 
      (fname, ftype, fid) = iprot.readFieldBegin()
21358 
      if ftype == TType.STOP:
21359 
        break
21360 
      if fid == 1:
21361 
        if ftype == TType.I64:
21362 
          self.vendorId = iprot.readI64();
21363 
        else:
21364 
          iprot.skip(ftype)
21365 
      else:
21366 
        iprot.skip(ftype)
21367 
      iprot.readFieldEnd()
21368 
    iprot.readStructEnd()
21369 
 
21370 
  def write(self, oprot):
21371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21373 
      return
21374 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21375 
    if self.vendorId is not None:
21376 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21377 
      oprot.writeI64(self.vendorId)
21378 
      oprot.writeFieldEnd()
21379 
    oprot.writeFieldStop()
21380 
    oprot.writeStructEnd()
21381 
 
21382 
  def validate(self):
21383 
    return
21384 
 
21385 
 
21386 
  def __repr__(self):
21387 
    L = ['%s=%r' % (key, value)
21388 
      for key, value in self.__dict__.iteritems()]
21389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21390 
 
21391 
  def __eq__(self, other):
21392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21393 
 
21394 
  def __ne__(self, other):
21395 
    return not (self == other)
21396 
 
21397 
class markOrdersAsTimeout_result:
21398 
  """
21399 
  Attributes:
21400 
   - success
21401 
   - ex
21402 
  """
21403 
 
21404 
  thrift_spec = (
21405 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21407 
  )
21408 
 
21409 
  def __init__(self, success=None, ex=None,):
21410 
    self.success = success
21411 
    self.ex = ex
21412 
 
21413 
  def read(self, iprot):
21414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21416 
      return
21417 
    iprot.readStructBegin()
21418 
    while True:
21419 
      (fname, ftype, fid) = iprot.readFieldBegin()
21420 
      if ftype == TType.STOP:
21421 
        break
21422 
      if fid == 0:
21423 
        if ftype == TType.MAP:
21424 
          self.success = {}
6031 rajveer 21425 
          (_ktype459, _vtype460, _size458 ) = iprot.readMapBegin()
21426 
          for _i462 in xrange(_size458):
21427 
            _key463 = iprot.readI32();
21428 
            _val464 = TimeoutSummary()
21429 
            _val464.read(iprot)
21430 
            self.success[_key463] = _val464
4369 rajveer 21431 
          iprot.readMapEnd()
21432 
        else:
21433 
          iprot.skip(ftype)
21434 
      elif fid == 1:
21435 
        if ftype == TType.STRUCT:
21436 
          self.ex = TransactionServiceException()
21437 
          self.ex.read(iprot)
21438 
        else:
21439 
          iprot.skip(ftype)
21440 
      else:
21441 
        iprot.skip(ftype)
21442 
      iprot.readFieldEnd()
21443 
    iprot.readStructEnd()
21444 
 
21445 
  def write(self, oprot):
21446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21448 
      return
21449 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21450 
    if self.success is not None:
21451 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21452 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6031 rajveer 21453 
      for kiter465,viter466 in self.success.items():
21454 
        oprot.writeI32(kiter465)
21455 
        viter466.write(oprot)
4369 rajveer 21456 
      oprot.writeMapEnd()
21457 
      oprot.writeFieldEnd()
21458 
    if self.ex is not None:
21459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21460 
      self.ex.write(oprot)
21461 
      oprot.writeFieldEnd()
21462 
    oprot.writeFieldStop()
21463 
    oprot.writeStructEnd()
21464 
 
21465 
  def validate(self):
21466 
    return
21467 
 
21468 
 
21469 
  def __repr__(self):
21470 
    L = ['%s=%r' % (key, value)
21471 
      for key, value in self.__dict__.iteritems()]
21472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21473 
 
21474 
  def __eq__(self, other):
21475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21476 
 
21477 
  def __ne__(self, other):
21478 
    return not (self == other)
4386 anupam.sin 21479 
 
4662 rajveer 21480 
class markOrderAsLostInTransit_args:
21481 
  """
21482 
  Attributes:
21483 
   - orderId
21484 
  """
21485 
 
21486 
  thrift_spec = (
21487 
    None, # 0
21488 
    (1, TType.I64, 'orderId', None, None, ), # 1
21489 
  )
21490 
 
21491 
  def __init__(self, orderId=None,):
21492 
    self.orderId = orderId
21493 
 
21494 
  def read(self, iprot):
21495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21497 
      return
21498 
    iprot.readStructBegin()
21499 
    while True:
21500 
      (fname, ftype, fid) = iprot.readFieldBegin()
21501 
      if ftype == TType.STOP:
21502 
        break
21503 
      if fid == 1:
21504 
        if ftype == TType.I64:
21505 
          self.orderId = iprot.readI64();
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('markOrderAsLostInTransit_args')
21518 
    if self.orderId is not None:
21519 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21520 
      oprot.writeI64(self.orderId)
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 markOrderAsLostInTransit_result:
21541 
  """
21542 
  Attributes:
21543 
   - success
21544 
   - ex
21545 
  """
21546 
 
21547 
  thrift_spec = (
21548 
    (0, TType.BOOL, 'success', None, None, ), # 0
21549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21550 
  )
21551 
 
21552 
  def __init__(self, success=None, ex=None,):
21553 
    self.success = success
21554 
    self.ex = ex
21555 
 
21556 
  def read(self, iprot):
21557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21559 
      return
21560 
    iprot.readStructBegin()
21561 
    while True:
21562 
      (fname, ftype, fid) = iprot.readFieldBegin()
21563 
      if ftype == TType.STOP:
21564 
        break
21565 
      if fid == 0:
21566 
        if ftype == TType.BOOL:
21567 
          self.success = iprot.readBool();
21568 
        else:
21569 
          iprot.skip(ftype)
21570 
      elif fid == 1:
21571 
        if ftype == TType.STRUCT:
21572 
          self.ex = TransactionServiceException()
21573 
          self.ex.read(iprot)
21574 
        else:
21575 
          iprot.skip(ftype)
21576 
      else:
21577 
        iprot.skip(ftype)
21578 
      iprot.readFieldEnd()
21579 
    iprot.readStructEnd()
21580 
 
21581 
  def write(self, oprot):
21582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21584 
      return
21585 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21586 
    if self.success is not None:
21587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21588 
      oprot.writeBool(self.success)
21589 
      oprot.writeFieldEnd()
21590 
    if self.ex is not None:
21591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21592 
      self.ex.write(oprot)
21593 
      oprot.writeFieldEnd()
21594 
    oprot.writeFieldStop()
21595 
    oprot.writeStructEnd()
21596 
 
21597 
  def validate(self):
21598 
    return
21599 
 
21600 
 
21601 
  def __repr__(self):
21602 
    L = ['%s=%r' % (key, value)
21603 
      for key, value in self.__dict__.iteritems()]
21604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21605 
 
21606 
  def __eq__(self, other):
21607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21608 
 
21609 
  def __ne__(self, other):
21610 
    return not (self == other)
21611 
 
4386 anupam.sin 21612 
class getOrderForAwb_args:
21613 
  """
21614 
  Attributes:
21615 
   - awb
21616 
  """
21617 
 
21618 
  thrift_spec = (
21619 
    None, # 0
21620 
    (1, TType.STRING, 'awb', None, None, ), # 1
21621 
  )
21622 
 
21623 
  def __init__(self, awb=None,):
21624 
    self.awb = awb
21625 
 
21626 
  def read(self, iprot):
21627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21629 
      return
21630 
    iprot.readStructBegin()
21631 
    while True:
21632 
      (fname, ftype, fid) = iprot.readFieldBegin()
21633 
      if ftype == TType.STOP:
21634 
        break
21635 
      if fid == 1:
21636 
        if ftype == TType.STRING:
21637 
          self.awb = iprot.readString();
21638 
        else:
21639 
          iprot.skip(ftype)
21640 
      else:
21641 
        iprot.skip(ftype)
21642 
      iprot.readFieldEnd()
21643 
    iprot.readStructEnd()
21644 
 
21645 
  def write(self, oprot):
21646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21648 
      return
21649 
    oprot.writeStructBegin('getOrderForAwb_args')
21650 
    if self.awb is not None:
21651 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21652 
      oprot.writeString(self.awb)
21653 
      oprot.writeFieldEnd()
21654 
    oprot.writeFieldStop()
21655 
    oprot.writeStructEnd()
21656 
 
21657 
  def validate(self):
21658 
    return
21659 
 
21660 
 
21661 
  def __repr__(self):
21662 
    L = ['%s=%r' % (key, value)
21663 
      for key, value in self.__dict__.iteritems()]
21664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21665 
 
21666 
  def __eq__(self, other):
21667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21668 
 
21669 
  def __ne__(self, other):
21670 
    return not (self == other)
21671 
 
21672 
class getOrderForAwb_result:
21673 
  """
21674 
  Attributes:
21675 
   - success
21676 
   - ex
21677 
  """
21678 
 
21679 
  thrift_spec = (
21680 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21682 
  )
21683 
 
21684 
  def __init__(self, success=None, ex=None,):
21685 
    self.success = success
21686 
    self.ex = ex
21687 
 
21688 
  def read(self, iprot):
21689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21691 
      return
21692 
    iprot.readStructBegin()
21693 
    while True:
21694 
      (fname, ftype, fid) = iprot.readFieldBegin()
21695 
      if ftype == TType.STOP:
21696 
        break
21697 
      if fid == 0:
21698 
        if ftype == TType.STRUCT:
21699 
          self.success = Order()
21700 
          self.success.read(iprot)
21701 
        else:
21702 
          iprot.skip(ftype)
21703 
      elif fid == 1:
21704 
        if ftype == TType.STRUCT:
21705 
          self.ex = TransactionServiceException()
21706 
          self.ex.read(iprot)
21707 
        else:
21708 
          iprot.skip(ftype)
21709 
      else:
21710 
        iprot.skip(ftype)
21711 
      iprot.readFieldEnd()
21712 
    iprot.readStructEnd()
21713 
 
21714 
  def write(self, oprot):
21715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21717 
      return
21718 
    oprot.writeStructBegin('getOrderForAwb_result')
21719 
    if self.success is not None:
21720 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21721 
      self.success.write(oprot)
21722 
      oprot.writeFieldEnd()
21723 
    if self.ex is not None:
21724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21725 
      self.ex.write(oprot)
21726 
      oprot.writeFieldEnd()
21727 
    oprot.writeFieldStop()
21728 
    oprot.writeStructEnd()
21729 
 
21730 
  def validate(self):
21731 
    return
21732 
 
21733 
 
21734 
  def __repr__(self):
21735 
    L = ['%s=%r' % (key, value)
21736 
      for key, value in self.__dict__.iteritems()]
21737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21738 
 
21739 
  def __eq__(self, other):
21740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21741 
 
21742 
  def __ne__(self, other):
21743 
    return not (self == other)
4506 phani.kuma 21744 
 
21745 
class getOrdersForProviderForStatus_args:
21746 
  """
21747 
  Attributes:
21748 
   - logistics_provider_id
4910 phani.kuma 21749 
   - order_status_list
4506 phani.kuma 21750 
  """
21751 
 
21752 
  thrift_spec = (
21753 
    None, # 0
21754 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 21755 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 21756 
  )
21757 
 
4910 phani.kuma 21758 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 21759 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 21760 
    self.order_status_list = order_status_list
4506 phani.kuma 21761 
 
21762 
  def read(self, iprot):
21763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21765 
      return
21766 
    iprot.readStructBegin()
21767 
    while True:
21768 
      (fname, ftype, fid) = iprot.readFieldBegin()
21769 
      if ftype == TType.STOP:
21770 
        break
21771 
      if fid == 1:
21772 
        if ftype == TType.I64:
21773 
          self.logistics_provider_id = iprot.readI64();
21774 
        else:
21775 
          iprot.skip(ftype)
21776 
      elif fid == 2:
4910 phani.kuma 21777 
        if ftype == TType.LIST:
21778 
          self.order_status_list = []
6031 rajveer 21779 
          (_etype470, _size467) = iprot.readListBegin()
21780 
          for _i471 in xrange(_size467):
21781 
            _elem472 = iprot.readI32();
21782 
            self.order_status_list.append(_elem472)
4910 phani.kuma 21783 
          iprot.readListEnd()
4506 phani.kuma 21784 
        else:
21785 
          iprot.skip(ftype)
21786 
      else:
21787 
        iprot.skip(ftype)
21788 
      iprot.readFieldEnd()
21789 
    iprot.readStructEnd()
21790 
 
21791 
  def write(self, oprot):
21792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21794 
      return
21795 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
21796 
    if self.logistics_provider_id is not None:
21797 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
21798 
      oprot.writeI64(self.logistics_provider_id)
21799 
      oprot.writeFieldEnd()
4910 phani.kuma 21800 
    if self.order_status_list is not None:
21801 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
21802 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6031 rajveer 21803 
      for iter473 in self.order_status_list:
21804 
        oprot.writeI32(iter473)
4910 phani.kuma 21805 
      oprot.writeListEnd()
4506 phani.kuma 21806 
      oprot.writeFieldEnd()
21807 
    oprot.writeFieldStop()
21808 
    oprot.writeStructEnd()
21809 
 
21810 
  def validate(self):
21811 
    return
21812 
 
21813 
 
21814 
  def __repr__(self):
21815 
    L = ['%s=%r' % (key, value)
21816 
      for key, value in self.__dict__.iteritems()]
21817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21818 
 
21819 
  def __eq__(self, other):
21820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21821 
 
21822 
  def __ne__(self, other):
21823 
    return not (self == other)
21824 
 
21825 
class getOrdersForProviderForStatus_result:
21826 
  """
21827 
  Attributes:
21828 
   - success
21829 
   - ex
21830 
  """
21831 
 
21832 
  thrift_spec = (
21833 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21834 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21835 
  )
21836 
 
21837 
  def __init__(self, success=None, ex=None,):
21838 
    self.success = success
21839 
    self.ex = ex
21840 
 
21841 
  def read(self, iprot):
21842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21844 
      return
21845 
    iprot.readStructBegin()
21846 
    while True:
21847 
      (fname, ftype, fid) = iprot.readFieldBegin()
21848 
      if ftype == TType.STOP:
21849 
        break
21850 
      if fid == 0:
21851 
        if ftype == TType.LIST:
21852 
          self.success = []
6031 rajveer 21853 
          (_etype477, _size474) = iprot.readListBegin()
21854 
          for _i478 in xrange(_size474):
21855 
            _elem479 = Order()
21856 
            _elem479.read(iprot)
21857 
            self.success.append(_elem479)
4506 phani.kuma 21858 
          iprot.readListEnd()
21859 
        else:
21860 
          iprot.skip(ftype)
21861 
      elif fid == 1:
21862 
        if ftype == TType.STRUCT:
21863 
          self.ex = TransactionServiceException()
21864 
          self.ex.read(iprot)
21865 
        else:
21866 
          iprot.skip(ftype)
21867 
      else:
21868 
        iprot.skip(ftype)
21869 
      iprot.readFieldEnd()
21870 
    iprot.readStructEnd()
21871 
 
21872 
  def write(self, oprot):
21873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21875 
      return
21876 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
21877 
    if self.success is not None:
21878 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21879 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 21880 
      for iter480 in self.success:
21881 
        iter480.write(oprot)
4506 phani.kuma 21882 
      oprot.writeListEnd()
21883 
      oprot.writeFieldEnd()
21884 
    if self.ex is not None:
21885 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21886 
      self.ex.write(oprot)
21887 
      oprot.writeFieldEnd()
21888 
    oprot.writeFieldStop()
21889 
    oprot.writeStructEnd()
21890 
 
21891 
  def validate(self):
21892 
    return
21893 
 
21894 
 
21895 
  def __repr__(self):
21896 
    L = ['%s=%r' % (key, value)
21897 
      for key, value in self.__dict__.iteritems()]
21898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21899 
 
21900 
  def __eq__(self, other):
21901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21902 
 
21903 
  def __ne__(self, other):
21904 
    return not (self == other)
4600 varun.gupt 21905 
 
21906 
class getBilledOrdersForVendor_args:
21907 
  """
21908 
  Attributes:
21909 
   - vendorId
21910 
   - billingDateFrom
21911 
   - billingDateTo
21912 
  """
21913 
 
21914 
  thrift_spec = (
21915 
    None, # 0
21916 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21917 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
21918 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
21919 
  )
21920 
 
21921 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
21922 
    self.vendorId = vendorId
21923 
    self.billingDateFrom = billingDateFrom
21924 
    self.billingDateTo = billingDateTo
21925 
 
21926 
  def read(self, iprot):
21927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21929 
      return
21930 
    iprot.readStructBegin()
21931 
    while True:
21932 
      (fname, ftype, fid) = iprot.readFieldBegin()
21933 
      if ftype == TType.STOP:
21934 
        break
21935 
      if fid == 1:
21936 
        if ftype == TType.I64:
21937 
          self.vendorId = iprot.readI64();
21938 
        else:
21939 
          iprot.skip(ftype)
21940 
      elif fid == 2:
21941 
        if ftype == TType.I64:
21942 
          self.billingDateFrom = iprot.readI64();
21943 
        else:
21944 
          iprot.skip(ftype)
21945 
      elif fid == 3:
21946 
        if ftype == TType.I64:
21947 
          self.billingDateTo = iprot.readI64();
21948 
        else:
21949 
          iprot.skip(ftype)
21950 
      else:
21951 
        iprot.skip(ftype)
21952 
      iprot.readFieldEnd()
21953 
    iprot.readStructEnd()
21954 
 
21955 
  def write(self, oprot):
21956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21958 
      return
21959 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
21960 
    if self.vendorId is not None:
21961 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21962 
      oprot.writeI64(self.vendorId)
21963 
      oprot.writeFieldEnd()
21964 
    if self.billingDateFrom is not None:
21965 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
21966 
      oprot.writeI64(self.billingDateFrom)
21967 
      oprot.writeFieldEnd()
21968 
    if self.billingDateTo is not None:
21969 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
21970 
      oprot.writeI64(self.billingDateTo)
21971 
      oprot.writeFieldEnd()
21972 
    oprot.writeFieldStop()
21973 
    oprot.writeStructEnd()
21974 
 
21975 
  def validate(self):
21976 
    return
21977 
 
21978 
 
21979 
  def __repr__(self):
21980 
    L = ['%s=%r' % (key, value)
21981 
      for key, value in self.__dict__.iteritems()]
21982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21983 
 
21984 
  def __eq__(self, other):
21985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21986 
 
21987 
  def __ne__(self, other):
21988 
    return not (self == other)
21989 
 
21990 
class getBilledOrdersForVendor_result:
21991 
  """
21992 
  Attributes:
21993 
   - success
21994 
   - ex
21995 
  """
21996 
 
21997 
  thrift_spec = (
21998 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21999 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22000 
  )
22001 
 
22002 
  def __init__(self, success=None, ex=None,):
22003 
    self.success = success
22004 
    self.ex = ex
22005 
 
22006 
  def read(self, iprot):
22007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22009 
      return
22010 
    iprot.readStructBegin()
22011 
    while True:
22012 
      (fname, ftype, fid) = iprot.readFieldBegin()
22013 
      if ftype == TType.STOP:
22014 
        break
22015 
      if fid == 0:
22016 
        if ftype == TType.LIST:
22017 
          self.success = []
6031 rajveer 22018 
          (_etype484, _size481) = iprot.readListBegin()
22019 
          for _i485 in xrange(_size481):
22020 
            _elem486 = Order()
22021 
            _elem486.read(iprot)
22022 
            self.success.append(_elem486)
4600 varun.gupt 22023 
          iprot.readListEnd()
22024 
        else:
22025 
          iprot.skip(ftype)
22026 
      elif fid == 1:
22027 
        if ftype == TType.STRUCT:
22028 
          self.ex = TransactionServiceException()
22029 
          self.ex.read(iprot)
22030 
        else:
22031 
          iprot.skip(ftype)
22032 
      else:
22033 
        iprot.skip(ftype)
22034 
      iprot.readFieldEnd()
22035 
    iprot.readStructEnd()
22036 
 
22037 
  def write(self, oprot):
22038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22040 
      return
22041 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22042 
    if self.success is not None:
22043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22045 
      for iter487 in self.success:
22046 
        iter487.write(oprot)
4600 varun.gupt 22047 
      oprot.writeListEnd()
22048 
      oprot.writeFieldEnd()
22049 
    if self.ex is not None:
22050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22051 
      self.ex.write(oprot)
22052 
      oprot.writeFieldEnd()
22053 
    oprot.writeFieldStop()
22054 
    oprot.writeStructEnd()
22055 
 
22056 
  def validate(self):
22057 
    return
22058 
 
22059 
 
22060 
  def __repr__(self):
22061 
    L = ['%s=%r' % (key, value)
22062 
      for key, value in self.__dict__.iteritems()]
22063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22064 
 
22065 
  def __eq__(self, other):
22066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22067 
 
22068 
  def __ne__(self, other):
22069 
    return not (self == other)
22070 
 
4607 rajveer 22071 
class getSlippedSippingDateOrders_args:
22072 
 
22073 
  thrift_spec = (
22074 
  )
22075 
 
22076 
  def read(self, iprot):
22077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22079 
      return
22080 
    iprot.readStructBegin()
22081 
    while True:
22082 
      (fname, ftype, fid) = iprot.readFieldBegin()
22083 
      if ftype == TType.STOP:
22084 
        break
22085 
      else:
22086 
        iprot.skip(ftype)
22087 
      iprot.readFieldEnd()
22088 
    iprot.readStructEnd()
22089 
 
22090 
  def write(self, oprot):
22091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22093 
      return
22094 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22095 
    oprot.writeFieldStop()
22096 
    oprot.writeStructEnd()
22097 
 
22098 
  def validate(self):
22099 
    return
22100 
 
22101 
 
22102 
  def __repr__(self):
22103 
    L = ['%s=%r' % (key, value)
22104 
      for key, value in self.__dict__.iteritems()]
22105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22106 
 
22107 
  def __eq__(self, other):
22108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22109 
 
22110 
  def __ne__(self, other):
22111 
    return not (self == other)
22112 
 
22113 
class getSlippedSippingDateOrders_result:
22114 
  """
22115 
  Attributes:
22116 
   - success
22117 
   - ex
22118 
  """
22119 
 
22120 
  thrift_spec = (
22121 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22122 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22123 
  )
22124 
 
22125 
  def __init__(self, success=None, ex=None,):
22126 
    self.success = success
22127 
    self.ex = ex
22128 
 
22129 
  def read(self, iprot):
22130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22132 
      return
22133 
    iprot.readStructBegin()
22134 
    while True:
22135 
      (fname, ftype, fid) = iprot.readFieldBegin()
22136 
      if ftype == TType.STOP:
22137 
        break
22138 
      if fid == 0:
22139 
        if ftype == TType.LIST:
22140 
          self.success = []
6031 rajveer 22141 
          (_etype491, _size488) = iprot.readListBegin()
22142 
          for _i492 in xrange(_size488):
22143 
            _elem493 = Order()
22144 
            _elem493.read(iprot)
22145 
            self.success.append(_elem493)
4607 rajveer 22146 
          iprot.readListEnd()
22147 
        else:
22148 
          iprot.skip(ftype)
22149 
      elif fid == 1:
22150 
        if ftype == TType.STRUCT:
22151 
          self.ex = TransactionServiceException()
22152 
          self.ex.read(iprot)
22153 
        else:
22154 
          iprot.skip(ftype)
22155 
      else:
22156 
        iprot.skip(ftype)
22157 
      iprot.readFieldEnd()
22158 
    iprot.readStructEnd()
22159 
 
22160 
  def write(self, oprot):
22161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22163 
      return
22164 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22165 
    if self.success is not None:
22166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22167 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22168 
      for iter494 in self.success:
22169 
        iter494.write(oprot)
4607 rajveer 22170 
      oprot.writeListEnd()
22171 
      oprot.writeFieldEnd()
22172 
    if self.ex is not None:
22173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22174 
      self.ex.write(oprot)
22175 
      oprot.writeFieldEnd()
22176 
    oprot.writeFieldStop()
22177 
    oprot.writeStructEnd()
22178 
 
22179 
  def validate(self):
22180 
    return
22181 
 
22182 
 
22183 
  def __repr__(self):
22184 
    L = ['%s=%r' % (key, value)
22185 
      for key, value in self.__dict__.iteritems()]
22186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22187 
 
22188 
  def __eq__(self, other):
22189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22190 
 
22191 
  def __ne__(self, other):
22192 
    return not (self == other)
22193 
 
4709 rajveer 22194 
class getCancelledOrders_args:
22195 
  """
22196 
  Attributes:
22197 
   - cancelDateFrom
22198 
   - cancelDateTo
22199 
  """
22200 
 
22201 
  thrift_spec = (
22202 
    None, # 0
22203 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22204 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22205 
  )
22206 
 
22207 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22208 
    self.cancelDateFrom = cancelDateFrom
22209 
    self.cancelDateTo = cancelDateTo
22210 
 
22211 
  def read(self, iprot):
22212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22214 
      return
22215 
    iprot.readStructBegin()
22216 
    while True:
22217 
      (fname, ftype, fid) = iprot.readFieldBegin()
22218 
      if ftype == TType.STOP:
22219 
        break
22220 
      if fid == 1:
22221 
        if ftype == TType.I64:
22222 
          self.cancelDateFrom = iprot.readI64();
22223 
        else:
22224 
          iprot.skip(ftype)
22225 
      elif fid == 2:
22226 
        if ftype == TType.I64:
22227 
          self.cancelDateTo = iprot.readI64();
22228 
        else:
22229 
          iprot.skip(ftype)
22230 
      else:
22231 
        iprot.skip(ftype)
22232 
      iprot.readFieldEnd()
22233 
    iprot.readStructEnd()
22234 
 
22235 
  def write(self, oprot):
22236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22238 
      return
22239 
    oprot.writeStructBegin('getCancelledOrders_args')
22240 
    if self.cancelDateFrom is not None:
22241 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22242 
      oprot.writeI64(self.cancelDateFrom)
22243 
      oprot.writeFieldEnd()
22244 
    if self.cancelDateTo is not None:
22245 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22246 
      oprot.writeI64(self.cancelDateTo)
22247 
      oprot.writeFieldEnd()
22248 
    oprot.writeFieldStop()
22249 
    oprot.writeStructEnd()
22250 
 
22251 
  def validate(self):
22252 
    return
22253 
 
22254 
 
22255 
  def __repr__(self):
22256 
    L = ['%s=%r' % (key, value)
22257 
      for key, value in self.__dict__.iteritems()]
22258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22259 
 
22260 
  def __eq__(self, other):
22261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22262 
 
22263 
  def __ne__(self, other):
22264 
    return not (self == other)
22265 
 
22266 
class getCancelledOrders_result:
22267 
  """
22268 
  Attributes:
22269 
   - success
22270 
   - ex
22271 
  """
22272 
 
22273 
  thrift_spec = (
22274 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22276 
  )
22277 
 
22278 
  def __init__(self, success=None, ex=None,):
22279 
    self.success = success
22280 
    self.ex = ex
22281 
 
22282 
  def read(self, iprot):
22283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22285 
      return
22286 
    iprot.readStructBegin()
22287 
    while True:
22288 
      (fname, ftype, fid) = iprot.readFieldBegin()
22289 
      if ftype == TType.STOP:
22290 
        break
22291 
      if fid == 0:
22292 
        if ftype == TType.LIST:
22293 
          self.success = []
6031 rajveer 22294 
          (_etype498, _size495) = iprot.readListBegin()
22295 
          for _i499 in xrange(_size495):
22296 
            _elem500 = Order()
22297 
            _elem500.read(iprot)
22298 
            self.success.append(_elem500)
4709 rajveer 22299 
          iprot.readListEnd()
22300 
        else:
22301 
          iprot.skip(ftype)
22302 
      elif fid == 1:
22303 
        if ftype == TType.STRUCT:
22304 
          self.ex = TransactionServiceException()
22305 
          self.ex.read(iprot)
22306 
        else:
22307 
          iprot.skip(ftype)
22308 
      else:
22309 
        iprot.skip(ftype)
22310 
      iprot.readFieldEnd()
22311 
    iprot.readStructEnd()
22312 
 
22313 
  def write(self, oprot):
22314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22316 
      return
22317 
    oprot.writeStructBegin('getCancelledOrders_result')
22318 
    if self.success is not None:
22319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 22321 
      for iter501 in self.success:
22322 
        iter501.write(oprot)
4709 rajveer 22323 
      oprot.writeListEnd()
22324 
      oprot.writeFieldEnd()
22325 
    if self.ex is not None:
22326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22327 
      self.ex.write(oprot)
22328 
      oprot.writeFieldEnd()
22329 
    oprot.writeFieldStop()
22330 
    oprot.writeStructEnd()
22331 
 
22332 
  def validate(self):
22333 
    return
22334 
 
22335 
 
22336 
  def __repr__(self):
22337 
    L = ['%s=%r' % (key, value)
22338 
      for key, value in self.__dict__.iteritems()]
22339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22340 
 
22341 
  def __eq__(self, other):
22342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22343 
 
22344 
  def __ne__(self, other):
22345 
    return not (self == other)
22346 
 
4600 varun.gupt 22347 
class saveBluedartSettlements_args:
22348 
  """
22349 
  Attributes:
22350 
   - mapAWBAndAmount
22351 
  """
22352 
 
22353 
  thrift_spec = (
22354 
    None, # 0
22355 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22356 
  )
22357 
 
22358 
  def __init__(self, mapAWBAndAmount=None,):
22359 
    self.mapAWBAndAmount = mapAWBAndAmount
22360 
 
22361 
  def read(self, iprot):
22362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22364 
      return
22365 
    iprot.readStructBegin()
22366 
    while True:
22367 
      (fname, ftype, fid) = iprot.readFieldBegin()
22368 
      if ftype == TType.STOP:
22369 
        break
22370 
      if fid == 1:
22371 
        if ftype == TType.MAP:
22372 
          self.mapAWBAndAmount = {}
6031 rajveer 22373 
          (_ktype503, _vtype504, _size502 ) = iprot.readMapBegin()
22374 
          for _i506 in xrange(_size502):
22375 
            _key507 = iprot.readI64();
22376 
            _val508 = iprot.readDouble();
22377 
            self.mapAWBAndAmount[_key507] = _val508
4600 varun.gupt 22378 
          iprot.readMapEnd()
22379 
        else:
22380 
          iprot.skip(ftype)
22381 
      else:
22382 
        iprot.skip(ftype)
22383 
      iprot.readFieldEnd()
22384 
    iprot.readStructEnd()
22385 
 
22386 
  def write(self, oprot):
22387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22389 
      return
22390 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22391 
    if self.mapAWBAndAmount is not None:
22392 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22393 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6031 rajveer 22394 
      for kiter509,viter510 in self.mapAWBAndAmount.items():
22395 
        oprot.writeI64(kiter509)
22396 
        oprot.writeDouble(viter510)
4600 varun.gupt 22397 
      oprot.writeMapEnd()
22398 
      oprot.writeFieldEnd()
22399 
    oprot.writeFieldStop()
22400 
    oprot.writeStructEnd()
22401 
 
22402 
  def validate(self):
22403 
    return
22404 
 
22405 
 
22406 
  def __repr__(self):
22407 
    L = ['%s=%r' % (key, value)
22408 
      for key, value in self.__dict__.iteritems()]
22409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22410 
 
22411 
  def __eq__(self, other):
22412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22413 
 
22414 
  def __ne__(self, other):
22415 
    return not (self == other)
22416 
 
22417 
class saveBluedartSettlements_result:
22418 
  """
22419 
  Attributes:
22420 
   - ex
22421 
  """
22422 
 
22423 
  thrift_spec = (
22424 
    None, # 0
22425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22426 
  )
22427 
 
22428 
  def __init__(self, ex=None,):
22429 
    self.ex = ex
22430 
 
22431 
  def read(self, iprot):
22432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22434 
      return
22435 
    iprot.readStructBegin()
22436 
    while True:
22437 
      (fname, ftype, fid) = iprot.readFieldBegin()
22438 
      if ftype == TType.STOP:
22439 
        break
22440 
      if fid == 1:
22441 
        if ftype == TType.STRUCT:
22442 
          self.ex = TransactionServiceException()
22443 
          self.ex.read(iprot)
22444 
        else:
22445 
          iprot.skip(ftype)
22446 
      else:
22447 
        iprot.skip(ftype)
22448 
      iprot.readFieldEnd()
22449 
    iprot.readStructEnd()
22450 
 
22451 
  def write(self, oprot):
22452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22454 
      return
22455 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22456 
    if self.ex is not None:
22457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22458 
      self.ex.write(oprot)
22459 
      oprot.writeFieldEnd()
22460 
    oprot.writeFieldStop()
22461 
    oprot.writeStructEnd()
22462 
 
22463 
  def validate(self):
22464 
    return
22465 
 
22466 
 
22467 
  def __repr__(self):
22468 
    L = ['%s=%r' % (key, value)
22469 
      for key, value in self.__dict__.iteritems()]
22470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22471 
 
22472 
  def __eq__(self, other):
22473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22474 
 
22475 
  def __ne__(self, other):
22476 
    return not (self == other)
22477 
 
22478 
class savePaymentSettlements_args:
22479 
  """
22480 
  Attributes:
22481 
   - settlementDate
22482 
   - paymentGatewayId
4905 varun.gupt 22483 
   - referenceId
4600 varun.gupt 22484 
   - serviceTax
22485 
   - otherCharges
22486 
   - netCollection
22487 
  """
22488 
 
22489 
  thrift_spec = (
22490 
    None, # 0
22491 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22492 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22493 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22494 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22495 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22496 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22497 
  )
22498 
 
4905 varun.gupt 22499 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22500 
    self.settlementDate = settlementDate
22501 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22502 
    self.referenceId = referenceId
4600 varun.gupt 22503 
    self.serviceTax = serviceTax
22504 
    self.otherCharges = otherCharges
22505 
    self.netCollection = netCollection
22506 
 
22507 
  def read(self, iprot):
22508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22510 
      return
22511 
    iprot.readStructBegin()
22512 
    while True:
22513 
      (fname, ftype, fid) = iprot.readFieldBegin()
22514 
      if ftype == TType.STOP:
22515 
        break
22516 
      if fid == 1:
22517 
        if ftype == TType.I64:
22518 
          self.settlementDate = iprot.readI64();
22519 
        else:
22520 
          iprot.skip(ftype)
22521 
      elif fid == 2:
22522 
        if ftype == TType.I64:
22523 
          self.paymentGatewayId = iprot.readI64();
22524 
        else:
22525 
          iprot.skip(ftype)
22526 
      elif fid == 3:
22527 
        if ftype == TType.I64:
4905 varun.gupt 22528 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22529 
        else:
22530 
          iprot.skip(ftype)
22531 
      elif fid == 4:
22532 
        if ftype == TType.DOUBLE:
22533 
          self.serviceTax = iprot.readDouble();
22534 
        else:
22535 
          iprot.skip(ftype)
22536 
      elif fid == 5:
22537 
        if ftype == TType.DOUBLE:
22538 
          self.otherCharges = iprot.readDouble();
22539 
        else:
22540 
          iprot.skip(ftype)
22541 
      elif fid == 6:
22542 
        if ftype == TType.DOUBLE:
22543 
          self.netCollection = iprot.readDouble();
22544 
        else:
22545 
          iprot.skip(ftype)
22546 
      else:
22547 
        iprot.skip(ftype)
22548 
      iprot.readFieldEnd()
22549 
    iprot.readStructEnd()
22550 
 
22551 
  def write(self, oprot):
22552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22554 
      return
22555 
    oprot.writeStructBegin('savePaymentSettlements_args')
22556 
    if self.settlementDate is not None:
22557 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22558 
      oprot.writeI64(self.settlementDate)
22559 
      oprot.writeFieldEnd()
22560 
    if self.paymentGatewayId is not None:
22561 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22562 
      oprot.writeI64(self.paymentGatewayId)
22563 
      oprot.writeFieldEnd()
4905 varun.gupt 22564 
    if self.referenceId is not None:
22565 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22566 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22567 
      oprot.writeFieldEnd()
22568 
    if self.serviceTax is not None:
22569 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22570 
      oprot.writeDouble(self.serviceTax)
22571 
      oprot.writeFieldEnd()
22572 
    if self.otherCharges is not None:
22573 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22574 
      oprot.writeDouble(self.otherCharges)
22575 
      oprot.writeFieldEnd()
22576 
    if self.netCollection is not None:
22577 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22578 
      oprot.writeDouble(self.netCollection)
22579 
      oprot.writeFieldEnd()
22580 
    oprot.writeFieldStop()
22581 
    oprot.writeStructEnd()
22582 
 
22583 
  def validate(self):
22584 
    return
22585 
 
22586 
 
22587 
  def __repr__(self):
22588 
    L = ['%s=%r' % (key, value)
22589 
      for key, value in self.__dict__.iteritems()]
22590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22591 
 
22592 
  def __eq__(self, other):
22593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22594 
 
22595 
  def __ne__(self, other):
22596 
    return not (self == other)
22597 
 
22598 
class savePaymentSettlements_result:
22599 
  """
22600 
  Attributes:
22601 
   - ex
22602 
  """
22603 
 
22604 
  thrift_spec = (
22605 
    None, # 0
22606 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22607 
  )
22608 
 
22609 
  def __init__(self, ex=None,):
22610 
    self.ex = ex
22611 
 
22612 
  def read(self, iprot):
22613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22615 
      return
22616 
    iprot.readStructBegin()
22617 
    while True:
22618 
      (fname, ftype, fid) = iprot.readFieldBegin()
22619 
      if ftype == TType.STOP:
22620 
        break
22621 
      if fid == 1:
22622 
        if ftype == TType.STRUCT:
22623 
          self.ex = TransactionServiceException()
22624 
          self.ex.read(iprot)
22625 
        else:
22626 
          iprot.skip(ftype)
22627 
      else:
22628 
        iprot.skip(ftype)
22629 
      iprot.readFieldEnd()
22630 
    iprot.readStructEnd()
22631 
 
22632 
  def write(self, oprot):
22633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22635 
      return
22636 
    oprot.writeStructBegin('savePaymentSettlements_result')
22637 
    if self.ex is not None:
22638 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22639 
      self.ex.write(oprot)
22640 
      oprot.writeFieldEnd()
22641 
    oprot.writeFieldStop()
22642 
    oprot.writeStructEnd()
22643 
 
22644 
  def validate(self):
22645 
    return
22646 
 
22647 
 
22648 
  def __repr__(self):
22649 
    L = ['%s=%r' % (key, value)
22650 
      for key, value in self.__dict__.iteritems()]
22651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22652 
 
22653 
  def __eq__(self, other):
22654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22655 
 
22656 
  def __ne__(self, other):
22657 
    return not (self == other)
22658 
 
22659 
class saveEBSSettlementSummary_args:
22660 
  """
22661 
  Attributes:
22662 
   - settlementId
22663 
   - settlementDate
22664 
   - transactionDateFrom
22665 
   - transactionDateTo
22666 
   - amount
22667 
  """
22668 
 
22669 
  thrift_spec = (
22670 
    None, # 0
22671 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22672 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22673 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22674 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22675 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22676 
  )
22677 
 
22678 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22679 
    self.settlementId = settlementId
22680 
    self.settlementDate = settlementDate
22681 
    self.transactionDateFrom = transactionDateFrom
22682 
    self.transactionDateTo = transactionDateTo
22683 
    self.amount = amount
22684 
 
22685 
  def read(self, iprot):
22686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22688 
      return
22689 
    iprot.readStructBegin()
22690 
    while True:
22691 
      (fname, ftype, fid) = iprot.readFieldBegin()
22692 
      if ftype == TType.STOP:
22693 
        break
22694 
      if fid == 1:
22695 
        if ftype == TType.I64:
22696 
          self.settlementId = iprot.readI64();
22697 
        else:
22698 
          iprot.skip(ftype)
22699 
      elif fid == 2:
22700 
        if ftype == TType.I64:
22701 
          self.settlementDate = iprot.readI64();
22702 
        else:
22703 
          iprot.skip(ftype)
22704 
      elif fid == 3:
22705 
        if ftype == TType.I64:
22706 
          self.transactionDateFrom = iprot.readI64();
22707 
        else:
22708 
          iprot.skip(ftype)
22709 
      elif fid == 4:
22710 
        if ftype == TType.I64:
22711 
          self.transactionDateTo = iprot.readI64();
22712 
        else:
22713 
          iprot.skip(ftype)
22714 
      elif fid == 5:
22715 
        if ftype == TType.DOUBLE:
22716 
          self.amount = iprot.readDouble();
22717 
        else:
22718 
          iprot.skip(ftype)
22719 
      else:
22720 
        iprot.skip(ftype)
22721 
      iprot.readFieldEnd()
22722 
    iprot.readStructEnd()
22723 
 
22724 
  def write(self, oprot):
22725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22727 
      return
22728 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22729 
    if self.settlementId is not None:
22730 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22731 
      oprot.writeI64(self.settlementId)
22732 
      oprot.writeFieldEnd()
22733 
    if self.settlementDate is not None:
22734 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22735 
      oprot.writeI64(self.settlementDate)
22736 
      oprot.writeFieldEnd()
22737 
    if self.transactionDateFrom is not None:
22738 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22739 
      oprot.writeI64(self.transactionDateFrom)
22740 
      oprot.writeFieldEnd()
22741 
    if self.transactionDateTo is not None:
22742 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
22743 
      oprot.writeI64(self.transactionDateTo)
22744 
      oprot.writeFieldEnd()
22745 
    if self.amount is not None:
22746 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
22747 
      oprot.writeDouble(self.amount)
22748 
      oprot.writeFieldEnd()
22749 
    oprot.writeFieldStop()
22750 
    oprot.writeStructEnd()
22751 
 
22752 
  def validate(self):
22753 
    return
22754 
 
22755 
 
22756 
  def __repr__(self):
22757 
    L = ['%s=%r' % (key, value)
22758 
      for key, value in self.__dict__.iteritems()]
22759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22760 
 
22761 
  def __eq__(self, other):
22762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22763 
 
22764 
  def __ne__(self, other):
22765 
    return not (self == other)
22766 
 
22767 
class saveEBSSettlementSummary_result:
22768 
  """
22769 
  Attributes:
22770 
   - ex
22771 
  """
22772 
 
22773 
  thrift_spec = (
22774 
    None, # 0
22775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22776 
  )
22777 
 
22778 
  def __init__(self, ex=None,):
22779 
    self.ex = ex
22780 
 
22781 
  def read(self, iprot):
22782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22784 
      return
22785 
    iprot.readStructBegin()
22786 
    while True:
22787 
      (fname, ftype, fid) = iprot.readFieldBegin()
22788 
      if ftype == TType.STOP:
22789 
        break
22790 
      if fid == 1:
22791 
        if ftype == TType.STRUCT:
22792 
          self.ex = TransactionServiceException()
22793 
          self.ex.read(iprot)
22794 
        else:
22795 
          iprot.skip(ftype)
22796 
      else:
22797 
        iprot.skip(ftype)
22798 
      iprot.readFieldEnd()
22799 
    iprot.readStructEnd()
22800 
 
22801 
  def write(self, oprot):
22802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22804 
      return
22805 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
22806 
    if self.ex is not None:
22807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22808 
      self.ex.write(oprot)
22809 
      oprot.writeFieldEnd()
22810 
    oprot.writeFieldStop()
22811 
    oprot.writeStructEnd()
22812 
 
22813 
  def validate(self):
22814 
    return
22815 
 
22816 
 
22817 
  def __repr__(self):
22818 
    L = ['%s=%r' % (key, value)
22819 
      for key, value in self.__dict__.iteritems()]
22820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22821 
 
22822 
  def __eq__(self, other):
22823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22824 
 
22825 
  def __ne__(self, other):
22826 
    return not (self == other)
22827 
 
5386 phani.kuma 22828 
class getSettlementForPrepaid_args:
4600 varun.gupt 22829 
  """
22830 
  Attributes:
5189 varun.gupt 22831 
   - referenceId
22832 
   - isRefund
4600 varun.gupt 22833 
  """
22834 
 
22835 
  thrift_spec = (
22836 
    None, # 0
5189 varun.gupt 22837 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 22838 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 22839 
  )
22840 
 
5386 phani.kuma 22841 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 22842 
    self.referenceId = referenceId
22843 
    self.isRefund = isRefund
4600 varun.gupt 22844 
 
22845 
  def read(self, iprot):
22846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22848 
      return
22849 
    iprot.readStructBegin()
22850 
    while True:
22851 
      (fname, ftype, fid) = iprot.readFieldBegin()
22852 
      if ftype == TType.STOP:
22853 
        break
22854 
      if fid == 1:
22855 
        if ftype == TType.I64:
5189 varun.gupt 22856 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22857 
        else:
22858 
          iprot.skip(ftype)
5189 varun.gupt 22859 
      elif fid == 2:
22860 
        if ftype == TType.BOOL:
22861 
          self.isRefund = iprot.readBool();
22862 
        else:
22863 
          iprot.skip(ftype)
4600 varun.gupt 22864 
      else:
22865 
        iprot.skip(ftype)
22866 
      iprot.readFieldEnd()
22867 
    iprot.readStructEnd()
22868 
 
22869 
  def write(self, oprot):
22870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22872 
      return
5386 phani.kuma 22873 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 22874 
    if self.referenceId is not None:
22875 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
22876 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22877 
      oprot.writeFieldEnd()
5386 phani.kuma 22878 
    if self.isRefund is not None:
22879 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
22880 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 22881 
      oprot.writeFieldEnd()
5386 phani.kuma 22882 
    oprot.writeFieldStop()
22883 
    oprot.writeStructEnd()
22884 
 
22885 
  def validate(self):
22886 
    return
22887 
 
22888 
 
22889 
  def __repr__(self):
22890 
    L = ['%s=%r' % (key, value)
22891 
      for key, value in self.__dict__.iteritems()]
22892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22893 
 
22894 
  def __eq__(self, other):
22895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22896 
 
22897 
  def __ne__(self, other):
22898 
    return not (self == other)
22899 
 
22900 
class getSettlementForPrepaid_result:
22901 
  """
22902 
  Attributes:
22903 
   - success
22904 
   - ex
22905 
  """
22906 
 
22907 
  thrift_spec = (
22908 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
22909 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22910 
  )
22911 
 
22912 
  def __init__(self, success=None, ex=None,):
22913 
    self.success = success
22914 
    self.ex = ex
22915 
 
22916 
  def read(self, iprot):
22917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22919 
      return
22920 
    iprot.readStructBegin()
22921 
    while True:
22922 
      (fname, ftype, fid) = iprot.readFieldBegin()
22923 
      if ftype == TType.STOP:
22924 
        break
22925 
      if fid == 0:
22926 
        if ftype == TType.STRUCT:
22927 
          self.success = PaymentSettlement()
22928 
          self.success.read(iprot)
22929 
        else:
22930 
          iprot.skip(ftype)
22931 
      elif fid == 1:
22932 
        if ftype == TType.STRUCT:
22933 
          self.ex = TransactionServiceException()
22934 
          self.ex.read(iprot)
22935 
        else:
22936 
          iprot.skip(ftype)
22937 
      else:
22938 
        iprot.skip(ftype)
22939 
      iprot.readFieldEnd()
22940 
    iprot.readStructEnd()
22941 
 
22942 
  def write(self, oprot):
22943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22945 
      return
22946 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
22947 
    if self.success is not None:
22948 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22949 
      self.success.write(oprot)
22950 
      oprot.writeFieldEnd()
22951 
    if self.ex is not None:
22952 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22953 
      self.ex.write(oprot)
22954 
      oprot.writeFieldEnd()
22955 
    oprot.writeFieldStop()
22956 
    oprot.writeStructEnd()
22957 
 
22958 
  def validate(self):
22959 
    return
22960 
 
22961 
 
22962 
  def __repr__(self):
22963 
    L = ['%s=%r' % (key, value)
22964 
      for key, value in self.__dict__.iteritems()]
22965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22966 
 
22967 
  def __eq__(self, other):
22968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22969 
 
22970 
  def __ne__(self, other):
22971 
    return not (self == other)
22972 
 
22973 
class getSettlementForCod_args:
22974 
  """
22975 
  Attributes:
22976 
   - orderId
22977 
   - isRefund
22978 
  """
22979 
 
22980 
  thrift_spec = (
22981 
    None, # 0
22982 
    (1, TType.I64, 'orderId', None, None, ), # 1
22983 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
22984 
  )
22985 
 
22986 
  def __init__(self, orderId=None, isRefund=None,):
22987 
    self.orderId = orderId
22988 
    self.isRefund = isRefund
22989 
 
22990 
  def read(self, iprot):
22991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22993 
      return
22994 
    iprot.readStructBegin()
22995 
    while True:
22996 
      (fname, ftype, fid) = iprot.readFieldBegin()
22997 
      if ftype == TType.STOP:
22998 
        break
22999 
      if fid == 1:
23000 
        if ftype == TType.I64:
23001 
          self.orderId = iprot.readI64();
23002 
        else:
23003 
          iprot.skip(ftype)
23004 
      elif fid == 2:
23005 
        if ftype == TType.BOOL:
23006 
          self.isRefund = iprot.readBool();
23007 
        else:
23008 
          iprot.skip(ftype)
23009 
      else:
23010 
        iprot.skip(ftype)
23011 
      iprot.readFieldEnd()
23012 
    iprot.readStructEnd()
23013 
 
23014 
  def write(self, oprot):
23015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23017 
      return
23018 
    oprot.writeStructBegin('getSettlementForCod_args')
23019 
    if self.orderId is not None:
23020 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23021 
      oprot.writeI64(self.orderId)
23022 
      oprot.writeFieldEnd()
5189 varun.gupt 23023 
    if self.isRefund is not None:
5386 phani.kuma 23024 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23025 
      oprot.writeBool(self.isRefund)
23026 
      oprot.writeFieldEnd()
4600 varun.gupt 23027 
    oprot.writeFieldStop()
23028 
    oprot.writeStructEnd()
23029 
 
23030 
  def validate(self):
23031 
    return
23032 
 
23033 
 
23034 
  def __repr__(self):
23035 
    L = ['%s=%r' % (key, value)
23036 
      for key, value in self.__dict__.iteritems()]
23037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23038 
 
23039 
  def __eq__(self, other):
23040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23041 
 
23042 
  def __ne__(self, other):
23043 
    return not (self == other)
23044 
 
5386 phani.kuma 23045 
class getSettlementForCod_result:
4600 varun.gupt 23046 
  """
23047 
  Attributes:
23048 
   - success
23049 
   - ex
23050 
  """
23051 
 
23052 
  thrift_spec = (
23053 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23054 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23055 
  )
23056 
 
23057 
  def __init__(self, success=None, ex=None,):
23058 
    self.success = success
23059 
    self.ex = ex
23060 
 
23061 
  def read(self, iprot):
23062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23064 
      return
23065 
    iprot.readStructBegin()
23066 
    while True:
23067 
      (fname, ftype, fid) = iprot.readFieldBegin()
23068 
      if ftype == TType.STOP:
23069 
        break
23070 
      if fid == 0:
23071 
        if ftype == TType.STRUCT:
23072 
          self.success = PaymentSettlement()
23073 
          self.success.read(iprot)
23074 
        else:
23075 
          iprot.skip(ftype)
23076 
      elif fid == 1:
23077 
        if ftype == TType.STRUCT:
23078 
          self.ex = TransactionServiceException()
23079 
          self.ex.read(iprot)
23080 
        else:
23081 
          iprot.skip(ftype)
23082 
      else:
23083 
        iprot.skip(ftype)
23084 
      iprot.readFieldEnd()
23085 
    iprot.readStructEnd()
23086 
 
23087 
  def write(self, oprot):
23088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23090 
      return
5386 phani.kuma 23091 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23092 
    if self.success is not None:
23093 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23094 
      self.success.write(oprot)
23095 
      oprot.writeFieldEnd()
23096 
    if self.ex is not None:
23097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23098 
      self.ex.write(oprot)
23099 
      oprot.writeFieldEnd()
23100 
    oprot.writeFieldStop()
23101 
    oprot.writeStructEnd()
23102 
 
23103 
  def validate(self):
23104 
    return
23105 
 
23106 
 
23107 
  def __repr__(self):
23108 
    L = ['%s=%r' % (key, value)
23109 
      for key, value in self.__dict__.iteritems()]
23110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23111 
 
23112 
  def __eq__(self, other):
23113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23114 
 
23115 
  def __ne__(self, other):
23116 
    return not (self == other)
23117 
 
23118 
class getEBSSettlementSummaries_args:
23119 
 
23120 
  thrift_spec = (
23121 
  )
23122 
 
23123 
  def read(self, iprot):
23124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23126 
      return
23127 
    iprot.readStructBegin()
23128 
    while True:
23129 
      (fname, ftype, fid) = iprot.readFieldBegin()
23130 
      if ftype == TType.STOP:
23131 
        break
23132 
      else:
23133 
        iprot.skip(ftype)
23134 
      iprot.readFieldEnd()
23135 
    iprot.readStructEnd()
23136 
 
23137 
  def write(self, oprot):
23138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23140 
      return
23141 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23142 
    oprot.writeFieldStop()
23143 
    oprot.writeStructEnd()
23144 
 
23145 
  def validate(self):
23146 
    return
23147 
 
23148 
 
23149 
  def __repr__(self):
23150 
    L = ['%s=%r' % (key, value)
23151 
      for key, value in self.__dict__.iteritems()]
23152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23153 
 
23154 
  def __eq__(self, other):
23155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23156 
 
23157 
  def __ne__(self, other):
23158 
    return not (self == other)
23159 
 
23160 
class getEBSSettlementSummaries_result:
23161 
  """
23162 
  Attributes:
23163 
   - success
23164 
   - ex
23165 
  """
23166 
 
23167 
  thrift_spec = (
23168 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23170 
  )
23171 
 
23172 
  def __init__(self, success=None, ex=None,):
23173 
    self.success = success
23174 
    self.ex = ex
23175 
 
23176 
  def read(self, iprot):
23177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23179 
      return
23180 
    iprot.readStructBegin()
23181 
    while True:
23182 
      (fname, ftype, fid) = iprot.readFieldBegin()
23183 
      if ftype == TType.STOP:
23184 
        break
23185 
      if fid == 0:
23186 
        if ftype == TType.MAP:
23187 
          self.success = {}
6031 rajveer 23188 
          (_ktype512, _vtype513, _size511 ) = iprot.readMapBegin()
23189 
          for _i515 in xrange(_size511):
23190 
            _key516 = iprot.readI64();
23191 
            _val517 = iprot.readString();
23192 
            self.success[_key516] = _val517
4600 varun.gupt 23193 
          iprot.readMapEnd()
23194 
        else:
23195 
          iprot.skip(ftype)
23196 
      elif fid == 1:
23197 
        if ftype == TType.STRUCT:
23198 
          self.ex = TransactionServiceException()
23199 
          self.ex.read(iprot)
23200 
        else:
23201 
          iprot.skip(ftype)
23202 
      else:
23203 
        iprot.skip(ftype)
23204 
      iprot.readFieldEnd()
23205 
    iprot.readStructEnd()
23206 
 
23207 
  def write(self, oprot):
23208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23210 
      return
23211 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23212 
    if self.success is not None:
23213 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23214 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6031 rajveer 23215 
      for kiter518,viter519 in self.success.items():
23216 
        oprot.writeI64(kiter518)
23217 
        oprot.writeString(viter519)
4600 varun.gupt 23218 
      oprot.writeMapEnd()
23219 
      oprot.writeFieldEnd()
23220 
    if self.ex is not None:
23221 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23222 
      self.ex.write(oprot)
23223 
      oprot.writeFieldEnd()
23224 
    oprot.writeFieldStop()
23225 
    oprot.writeStructEnd()
23226 
 
23227 
  def validate(self):
23228 
    return
23229 
 
23230 
 
23231 
  def __repr__(self):
23232 
    L = ['%s=%r' % (key, value)
23233 
      for key, value in self.__dict__.iteritems()]
23234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23235 
 
23236 
  def __eq__(self, other):
23237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23238 
 
23239 
  def __ne__(self, other):
23240 
    return not (self == other)
23241 
 
23242 
class markEBSSettlementUploaded_args:
23243 
  """
23244 
  Attributes:
23245 
   - settlementId
23246 
  """
23247 
 
23248 
  thrift_spec = (
23249 
    None, # 0
23250 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23251 
  )
23252 
 
23253 
  def __init__(self, settlementId=None,):
23254 
    self.settlementId = settlementId
23255 
 
23256 
  def read(self, iprot):
23257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23259 
      return
23260 
    iprot.readStructBegin()
23261 
    while True:
23262 
      (fname, ftype, fid) = iprot.readFieldBegin()
23263 
      if ftype == TType.STOP:
23264 
        break
23265 
      if fid == 1:
23266 
        if ftype == TType.I64:
23267 
          self.settlementId = iprot.readI64();
23268 
        else:
23269 
          iprot.skip(ftype)
23270 
      else:
23271 
        iprot.skip(ftype)
23272 
      iprot.readFieldEnd()
23273 
    iprot.readStructEnd()
23274 
 
23275 
  def write(self, oprot):
23276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23278 
      return
23279 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23280 
    if self.settlementId is not None:
23281 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23282 
      oprot.writeI64(self.settlementId)
23283 
      oprot.writeFieldEnd()
23284 
    oprot.writeFieldStop()
23285 
    oprot.writeStructEnd()
23286 
 
23287 
  def validate(self):
23288 
    return
23289 
 
23290 
 
23291 
  def __repr__(self):
23292 
    L = ['%s=%r' % (key, value)
23293 
      for key, value in self.__dict__.iteritems()]
23294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23295 
 
23296 
  def __eq__(self, other):
23297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23298 
 
23299 
  def __ne__(self, other):
23300 
    return not (self == other)
23301 
 
23302 
class markEBSSettlementUploaded_result:
23303 
  """
23304 
  Attributes:
23305 
   - ex
23306 
  """
23307 
 
23308 
  thrift_spec = (
23309 
    None, # 0
23310 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23311 
  )
23312 
 
23313 
  def __init__(self, ex=None,):
23314 
    self.ex = ex
23315 
 
23316 
  def read(self, iprot):
23317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23319 
      return
23320 
    iprot.readStructBegin()
23321 
    while True:
23322 
      (fname, ftype, fid) = iprot.readFieldBegin()
23323 
      if ftype == TType.STOP:
23324 
        break
23325 
      if fid == 1:
23326 
        if ftype == TType.STRUCT:
23327 
          self.ex = TransactionServiceException()
23328 
          self.ex.read(iprot)
23329 
        else:
23330 
          iprot.skip(ftype)
23331 
      else:
23332 
        iprot.skip(ftype)
23333 
      iprot.readFieldEnd()
23334 
    iprot.readStructEnd()
23335 
 
23336 
  def write(self, oprot):
23337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23339 
      return
23340 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23341 
    if self.ex is not None:
23342 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23343 
      self.ex.write(oprot)
23344 
      oprot.writeFieldEnd()
23345 
    oprot.writeFieldStop()
23346 
    oprot.writeStructEnd()
23347 
 
23348 
  def validate(self):
23349 
    return
23350 
 
23351 
 
23352 
  def __repr__(self):
23353 
    L = ['%s=%r' % (key, value)
23354 
      for key, value in self.__dict__.iteritems()]
23355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23356 
 
23357 
  def __eq__(self, other):
23358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23359 
 
23360 
  def __ne__(self, other):
23361 
    return not (self == other)
23362 
 
23363 
class getEBSSettlementDate_args:
23364 
  """
23365 
  Attributes:
23366 
   - settlementId
23367 
  """
23368 
 
23369 
  thrift_spec = (
23370 
    None, # 0
23371 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23372 
  )
23373 
 
23374 
  def __init__(self, settlementId=None,):
23375 
    self.settlementId = settlementId
23376 
 
23377 
  def read(self, iprot):
23378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23380 
      return
23381 
    iprot.readStructBegin()
23382 
    while True:
23383 
      (fname, ftype, fid) = iprot.readFieldBegin()
23384 
      if ftype == TType.STOP:
23385 
        break
23386 
      if fid == 1:
23387 
        if ftype == TType.I64:
23388 
          self.settlementId = iprot.readI64();
23389 
        else:
23390 
          iprot.skip(ftype)
23391 
      else:
23392 
        iprot.skip(ftype)
23393 
      iprot.readFieldEnd()
23394 
    iprot.readStructEnd()
23395 
 
23396 
  def write(self, oprot):
23397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23399 
      return
23400 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23401 
    if self.settlementId is not None:
23402 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23403 
      oprot.writeI64(self.settlementId)
23404 
      oprot.writeFieldEnd()
23405 
    oprot.writeFieldStop()
23406 
    oprot.writeStructEnd()
23407 
 
23408 
  def validate(self):
23409 
    return
23410 
 
23411 
 
23412 
  def __repr__(self):
23413 
    L = ['%s=%r' % (key, value)
23414 
      for key, value in self.__dict__.iteritems()]
23415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23416 
 
23417 
  def __eq__(self, other):
23418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23419 
 
23420 
  def __ne__(self, other):
23421 
    return not (self == other)
23422 
 
23423 
class getEBSSettlementDate_result:
23424 
  """
23425 
  Attributes:
23426 
   - success
23427 
   - ex
23428 
  """
23429 
 
23430 
  thrift_spec = (
23431 
    (0, TType.I64, 'success', None, None, ), # 0
23432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23433 
  )
23434 
 
23435 
  def __init__(self, success=None, ex=None,):
23436 
    self.success = success
23437 
    self.ex = ex
23438 
 
23439 
  def read(self, iprot):
23440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23442 
      return
23443 
    iprot.readStructBegin()
23444 
    while True:
23445 
      (fname, ftype, fid) = iprot.readFieldBegin()
23446 
      if ftype == TType.STOP:
23447 
        break
23448 
      if fid == 0:
23449 
        if ftype == TType.I64:
23450 
          self.success = iprot.readI64();
23451 
        else:
23452 
          iprot.skip(ftype)
23453 
      elif fid == 1:
23454 
        if ftype == TType.STRUCT:
23455 
          self.ex = TransactionServiceException()
23456 
          self.ex.read(iprot)
23457 
        else:
23458 
          iprot.skip(ftype)
23459 
      else:
23460 
        iprot.skip(ftype)
23461 
      iprot.readFieldEnd()
23462 
    iprot.readStructEnd()
23463 
 
23464 
  def write(self, oprot):
23465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23467 
      return
23468 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23469 
    if self.success is not None:
23470 
      oprot.writeFieldBegin('success', TType.I64, 0)
23471 
      oprot.writeI64(self.success)
23472 
      oprot.writeFieldEnd()
23473 
    if self.ex is not None:
23474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23475 
      self.ex.write(oprot)
23476 
      oprot.writeFieldEnd()
23477 
    oprot.writeFieldStop()
23478 
    oprot.writeStructEnd()
23479 
 
23480 
  def validate(self):
23481 
    return
23482 
 
23483 
 
23484 
  def __repr__(self):
23485 
    L = ['%s=%r' % (key, value)
23486 
      for key, value in self.__dict__.iteritems()]
23487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23488 
 
23489 
  def __eq__(self, other):
23490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23491 
 
23492 
  def __ne__(self, other):
23493 
    return not (self == other)
4715 varun.gupt 23494 
 
23495 
class getSettlementsByDate_args:
23496 
  """
23497 
  Attributes:
23498 
   - settlementDateFrom
23499 
   - settlementDateTo
23500 
   - isRefund
23501 
  """
23502 
 
23503 
  thrift_spec = (
23504 
    None, # 0
23505 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23506 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23507 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23508 
  )
23509 
 
23510 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23511 
    self.settlementDateFrom = settlementDateFrom
23512 
    self.settlementDateTo = settlementDateTo
23513 
    self.isRefund = isRefund
23514 
 
23515 
  def read(self, iprot):
23516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23518 
      return
23519 
    iprot.readStructBegin()
23520 
    while True:
23521 
      (fname, ftype, fid) = iprot.readFieldBegin()
23522 
      if ftype == TType.STOP:
23523 
        break
23524 
      if fid == 1:
23525 
        if ftype == TType.I64:
23526 
          self.settlementDateFrom = iprot.readI64();
23527 
        else:
23528 
          iprot.skip(ftype)
23529 
      elif fid == 2:
23530 
        if ftype == TType.I64:
23531 
          self.settlementDateTo = iprot.readI64();
23532 
        else:
23533 
          iprot.skip(ftype)
23534 
      elif fid == 3:
23535 
        if ftype == TType.BOOL:
23536 
          self.isRefund = iprot.readBool();
23537 
        else:
23538 
          iprot.skip(ftype)
23539 
      else:
23540 
        iprot.skip(ftype)
23541 
      iprot.readFieldEnd()
23542 
    iprot.readStructEnd()
23543 
 
23544 
  def write(self, oprot):
23545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23547 
      return
23548 
    oprot.writeStructBegin('getSettlementsByDate_args')
23549 
    if self.settlementDateFrom is not None:
23550 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23551 
      oprot.writeI64(self.settlementDateFrom)
23552 
      oprot.writeFieldEnd()
23553 
    if self.settlementDateTo is not None:
23554 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23555 
      oprot.writeI64(self.settlementDateTo)
23556 
      oprot.writeFieldEnd()
23557 
    if self.isRefund is not None:
23558 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23559 
      oprot.writeBool(self.isRefund)
23560 
      oprot.writeFieldEnd()
23561 
    oprot.writeFieldStop()
23562 
    oprot.writeStructEnd()
23563 
 
23564 
  def validate(self):
23565 
    return
23566 
 
23567 
 
23568 
  def __repr__(self):
23569 
    L = ['%s=%r' % (key, value)
23570 
      for key, value in self.__dict__.iteritems()]
23571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23572 
 
23573 
  def __eq__(self, other):
23574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23575 
 
23576 
  def __ne__(self, other):
23577 
    return not (self == other)
23578 
 
23579 
class getSettlementsByDate_result:
23580 
  """
23581 
  Attributes:
23582 
   - success
23583 
   - ex
23584 
  """
23585 
 
23586 
  thrift_spec = (
23587 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23589 
  )
23590 
 
23591 
  def __init__(self, success=None, ex=None,):
23592 
    self.success = success
23593 
    self.ex = ex
23594 
 
23595 
  def read(self, iprot):
23596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23598 
      return
23599 
    iprot.readStructBegin()
23600 
    while True:
23601 
      (fname, ftype, fid) = iprot.readFieldBegin()
23602 
      if ftype == TType.STOP:
23603 
        break
23604 
      if fid == 0:
23605 
        if ftype == TType.LIST:
23606 
          self.success = []
6031 rajveer 23607 
          (_etype523, _size520) = iprot.readListBegin()
23608 
          for _i524 in xrange(_size520):
23609 
            _elem525 = PaymentSettlement()
23610 
            _elem525.read(iprot)
23611 
            self.success.append(_elem525)
4715 varun.gupt 23612 
          iprot.readListEnd()
23613 
        else:
23614 
          iprot.skip(ftype)
23615 
      elif fid == 1:
23616 
        if ftype == TType.STRUCT:
23617 
          self.ex = TransactionServiceException()
23618 
          self.ex.read(iprot)
23619 
        else:
23620 
          iprot.skip(ftype)
23621 
      else:
23622 
        iprot.skip(ftype)
23623 
      iprot.readFieldEnd()
23624 
    iprot.readStructEnd()
23625 
 
23626 
  def write(self, oprot):
23627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23629 
      return
23630 
    oprot.writeStructBegin('getSettlementsByDate_result')
23631 
    if self.success is not None:
23632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23634 
      for iter526 in self.success:
23635 
        iter526.write(oprot)
4715 varun.gupt 23636 
      oprot.writeListEnd()
23637 
      oprot.writeFieldEnd()
23638 
    if self.ex is not None:
23639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23640 
      self.ex.write(oprot)
23641 
      oprot.writeFieldEnd()
23642 
    oprot.writeFieldStop()
23643 
    oprot.writeStructEnd()
23644 
 
23645 
  def validate(self):
23646 
    return
23647 
 
23648 
 
23649 
  def __repr__(self):
23650 
    L = ['%s=%r' % (key, value)
23651 
      for key, value in self.__dict__.iteritems()]
23652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23653 
 
23654 
  def __eq__(self, other):
23655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23656 
 
23657 
  def __ne__(self, other):
23658 
    return not (self == other)
23659 
 
23660 
class getReshippedOrderIds_args:
23661 
  """
23662 
  Attributes:
23663 
   - orderIds
23664 
  """
23665 
 
23666 
  thrift_spec = (
23667 
    None, # 0
23668 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23669 
  )
23670 
 
23671 
  def __init__(self, orderIds=None,):
23672 
    self.orderIds = orderIds
23673 
 
23674 
  def read(self, iprot):
23675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23677 
      return
23678 
    iprot.readStructBegin()
23679 
    while True:
23680 
      (fname, ftype, fid) = iprot.readFieldBegin()
23681 
      if ftype == TType.STOP:
23682 
        break
23683 
      if fid == 1:
23684 
        if ftype == TType.LIST:
23685 
          self.orderIds = []
6031 rajveer 23686 
          (_etype530, _size527) = iprot.readListBegin()
23687 
          for _i531 in xrange(_size527):
23688 
            _elem532 = iprot.readI64();
23689 
            self.orderIds.append(_elem532)
4715 varun.gupt 23690 
          iprot.readListEnd()
23691 
        else:
23692 
          iprot.skip(ftype)
23693 
      else:
23694 
        iprot.skip(ftype)
23695 
      iprot.readFieldEnd()
23696 
    iprot.readStructEnd()
23697 
 
23698 
  def write(self, oprot):
23699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23701 
      return
23702 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23703 
    if self.orderIds is not None:
23704 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23705 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6031 rajveer 23706 
      for iter533 in self.orderIds:
23707 
        oprot.writeI64(iter533)
4715 varun.gupt 23708 
      oprot.writeListEnd()
23709 
      oprot.writeFieldEnd()
23710 
    oprot.writeFieldStop()
23711 
    oprot.writeStructEnd()
23712 
 
23713 
  def validate(self):
23714 
    return
23715 
 
23716 
 
23717 
  def __repr__(self):
23718 
    L = ['%s=%r' % (key, value)
23719 
      for key, value in self.__dict__.iteritems()]
23720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23721 
 
23722 
  def __eq__(self, other):
23723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23724 
 
23725 
  def __ne__(self, other):
23726 
    return not (self == other)
23727 
 
23728 
class getReshippedOrderIds_result:
23729 
  """
23730 
  Attributes:
23731 
   - success
23732 
   - ex
23733 
  """
23734 
 
23735 
  thrift_spec = (
23736 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23738 
  )
23739 
 
23740 
  def __init__(self, success=None, ex=None,):
23741 
    self.success = success
23742 
    self.ex = ex
23743 
 
23744 
  def read(self, iprot):
23745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23747 
      return
23748 
    iprot.readStructBegin()
23749 
    while True:
23750 
      (fname, ftype, fid) = iprot.readFieldBegin()
23751 
      if ftype == TType.STOP:
23752 
        break
23753 
      if fid == 0:
23754 
        if ftype == TType.LIST:
23755 
          self.success = []
6031 rajveer 23756 
          (_etype537, _size534) = iprot.readListBegin()
23757 
          for _i538 in xrange(_size534):
23758 
            _elem539 = iprot.readI64();
23759 
            self.success.append(_elem539)
4715 varun.gupt 23760 
          iprot.readListEnd()
23761 
        else:
23762 
          iprot.skip(ftype)
23763 
      elif fid == 1:
23764 
        if ftype == TType.STRUCT:
23765 
          self.ex = TransactionServiceException()
23766 
          self.ex.read(iprot)
23767 
        else:
23768 
          iprot.skip(ftype)
23769 
      else:
23770 
        iprot.skip(ftype)
23771 
      iprot.readFieldEnd()
23772 
    iprot.readStructEnd()
23773 
 
23774 
  def write(self, oprot):
23775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23777 
      return
23778 
    oprot.writeStructBegin('getReshippedOrderIds_result')
23779 
    if self.success is not None:
23780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23781 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 23782 
      for iter540 in self.success:
23783 
        oprot.writeI64(iter540)
4715 varun.gupt 23784 
      oprot.writeListEnd()
23785 
      oprot.writeFieldEnd()
23786 
    if self.ex is not None:
23787 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23788 
      self.ex.write(oprot)
23789 
      oprot.writeFieldEnd()
23790 
    oprot.writeFieldStop()
23791 
    oprot.writeStructEnd()
23792 
 
23793 
  def validate(self):
23794 
    return
23795 
 
23796 
 
23797 
  def __repr__(self):
23798 
    L = ['%s=%r' % (key, value)
23799 
      for key, value in self.__dict__.iteritems()]
23800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23801 
 
23802 
  def __eq__(self, other):
23803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23804 
 
23805 
  def __ne__(self, other):
23806 
    return not (self == other)
4757 mandeep.dh 23807 
 
5481 phani.kuma 23808 
class getBilledOrders_args:
4875 varun.gupt 23809 
  """
23810 
  Attributes:
23811 
   - vendorId
5481 phani.kuma 23812 
   - onlyVendorNotPaid
23813 
   - billingDateFrom
23814 
   - billingDateTo
4875 varun.gupt 23815 
  """
23816 
 
23817 
  thrift_spec = (
23818 
    None, # 0
23819 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 23820 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
23821 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
23822 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 23823 
  )
23824 
 
5481 phani.kuma 23825 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 23826 
    self.vendorId = vendorId
5481 phani.kuma 23827 
    self.onlyVendorNotPaid = onlyVendorNotPaid
23828 
    self.billingDateFrom = billingDateFrom
23829 
    self.billingDateTo = billingDateTo
4875 varun.gupt 23830 
 
23831 
  def read(self, iprot):
23832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23834 
      return
23835 
    iprot.readStructBegin()
23836 
    while True:
23837 
      (fname, ftype, fid) = iprot.readFieldBegin()
23838 
      if ftype == TType.STOP:
23839 
        break
23840 
      if fid == 1:
23841 
        if ftype == TType.I64:
23842 
          self.vendorId = iprot.readI64();
23843 
        else:
23844 
          iprot.skip(ftype)
5481 phani.kuma 23845 
      elif fid == 2:
23846 
        if ftype == TType.BOOL:
23847 
          self.onlyVendorNotPaid = iprot.readBool();
23848 
        else:
23849 
          iprot.skip(ftype)
23850 
      elif fid == 3:
23851 
        if ftype == TType.I64:
23852 
          self.billingDateFrom = iprot.readI64();
23853 
        else:
23854 
          iprot.skip(ftype)
23855 
      elif fid == 4:
23856 
        if ftype == TType.I64:
23857 
          self.billingDateTo = iprot.readI64();
23858 
        else:
23859 
          iprot.skip(ftype)
4875 varun.gupt 23860 
      else:
23861 
        iprot.skip(ftype)
23862 
      iprot.readFieldEnd()
23863 
    iprot.readStructEnd()
23864 
 
23865 
  def write(self, oprot):
23866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23868 
      return
5481 phani.kuma 23869 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 23870 
    if self.vendorId is not None:
23871 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23872 
      oprot.writeI64(self.vendorId)
23873 
      oprot.writeFieldEnd()
5481 phani.kuma 23874 
    if self.onlyVendorNotPaid is not None:
23875 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
23876 
      oprot.writeBool(self.onlyVendorNotPaid)
23877 
      oprot.writeFieldEnd()
23878 
    if self.billingDateFrom is not None:
23879 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
23880 
      oprot.writeI64(self.billingDateFrom)
23881 
      oprot.writeFieldEnd()
23882 
    if self.billingDateTo is not None:
23883 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
23884 
      oprot.writeI64(self.billingDateTo)
23885 
      oprot.writeFieldEnd()
4875 varun.gupt 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 
 
5481 phani.kuma 23904 
class getBilledOrders_result:
4875 varun.gupt 23905 
  """
23906 
  Attributes:
23907 
   - success
23908 
   - ex
23909 
  """
23910 
 
23911 
  thrift_spec = (
23912 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23913 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23914 
  )
23915 
 
23916 
  def __init__(self, success=None, ex=None,):
23917 
    self.success = success
23918 
    self.ex = ex
23919 
 
23920 
  def read(self, iprot):
23921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23923 
      return
23924 
    iprot.readStructBegin()
23925 
    while True:
23926 
      (fname, ftype, fid) = iprot.readFieldBegin()
23927 
      if ftype == TType.STOP:
23928 
        break
23929 
      if fid == 0:
23930 
        if ftype == TType.LIST:
23931 
          self.success = []
6031 rajveer 23932 
          (_etype544, _size541) = iprot.readListBegin()
23933 
          for _i545 in xrange(_size541):
23934 
            _elem546 = Order()
23935 
            _elem546.read(iprot)
23936 
            self.success.append(_elem546)
4875 varun.gupt 23937 
          iprot.readListEnd()
23938 
        else:
23939 
          iprot.skip(ftype)
23940 
      elif fid == 1:
23941 
        if ftype == TType.STRUCT:
23942 
          self.ex = TransactionServiceException()
23943 
          self.ex.read(iprot)
23944 
        else:
23945 
          iprot.skip(ftype)
23946 
      else:
23947 
        iprot.skip(ftype)
23948 
      iprot.readFieldEnd()
23949 
    iprot.readStructEnd()
23950 
 
23951 
  def write(self, oprot):
23952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23954 
      return
5481 phani.kuma 23955 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 23956 
    if self.success is not None:
23957 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23958 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 23959 
      for iter547 in self.success:
23960 
        iter547.write(oprot)
4875 varun.gupt 23961 
      oprot.writeListEnd()
23962 
      oprot.writeFieldEnd()
23963 
    if self.ex is not None:
23964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23965 
      self.ex.write(oprot)
23966 
      oprot.writeFieldEnd()
23967 
    oprot.writeFieldStop()
23968 
    oprot.writeStructEnd()
23969 
 
23970 
  def validate(self):
23971 
    return
23972 
 
23973 
 
23974 
  def __repr__(self):
23975 
    L = ['%s=%r' % (key, value)
23976 
      for key, value in self.__dict__.iteritems()]
23977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23978 
 
23979 
  def __eq__(self, other):
23980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23981 
 
23982 
  def __ne__(self, other):
23983 
    return not (self == other)
5031 varun.gupt 23984 
 
23985 
class getStatusDistributionOfOrders_args:
23986 
  """
23987 
  Attributes:
23988 
   - startDate
23989 
   - endDate
23990 
  """
23991 
 
23992 
  thrift_spec = (
23993 
    None, # 0
23994 
    (1, TType.I64, 'startDate', None, None, ), # 1
23995 
    (2, TType.I64, 'endDate', None, None, ), # 2
23996 
  )
23997 
 
23998 
  def __init__(self, startDate=None, endDate=None,):
23999 
    self.startDate = startDate
24000 
    self.endDate = endDate
24001 
 
24002 
  def read(self, iprot):
24003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24005 
      return
24006 
    iprot.readStructBegin()
24007 
    while True:
24008 
      (fname, ftype, fid) = iprot.readFieldBegin()
24009 
      if ftype == TType.STOP:
24010 
        break
24011 
      if fid == 1:
24012 
        if ftype == TType.I64:
24013 
          self.startDate = iprot.readI64();
24014 
        else:
24015 
          iprot.skip(ftype)
24016 
      elif fid == 2:
24017 
        if ftype == TType.I64:
24018 
          self.endDate = iprot.readI64();
24019 
        else:
24020 
          iprot.skip(ftype)
24021 
      else:
24022 
        iprot.skip(ftype)
24023 
      iprot.readFieldEnd()
24024 
    iprot.readStructEnd()
24025 
 
24026 
  def write(self, oprot):
24027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24029 
      return
24030 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24031 
    if self.startDate is not None:
24032 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24033 
      oprot.writeI64(self.startDate)
24034 
      oprot.writeFieldEnd()
24035 
    if self.endDate is not None:
24036 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24037 
      oprot.writeI64(self.endDate)
24038 
      oprot.writeFieldEnd()
24039 
    oprot.writeFieldStop()
24040 
    oprot.writeStructEnd()
24041 
 
24042 
  def validate(self):
24043 
    return
24044 
 
24045 
 
24046 
  def __repr__(self):
24047 
    L = ['%s=%r' % (key, value)
24048 
      for key, value in self.__dict__.iteritems()]
24049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24050 
 
24051 
  def __eq__(self, other):
24052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24053 
 
24054 
  def __ne__(self, other):
24055 
    return not (self == other)
24056 
 
24057 
class getStatusDistributionOfOrders_result:
24058 
  """
24059 
  Attributes:
24060 
   - success
24061 
   - ex
24062 
  """
24063 
 
24064 
  thrift_spec = (
24065 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24067 
  )
24068 
 
24069 
  def __init__(self, success=None, ex=None,):
24070 
    self.success = success
24071 
    self.ex = ex
24072 
 
24073 
  def read(self, iprot):
24074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24076 
      return
24077 
    iprot.readStructBegin()
24078 
    while True:
24079 
      (fname, ftype, fid) = iprot.readFieldBegin()
24080 
      if ftype == TType.STOP:
24081 
        break
24082 
      if fid == 0:
24083 
        if ftype == TType.MAP:
24084 
          self.success = {}
6031 rajveer 24085 
          (_ktype549, _vtype550, _size548 ) = iprot.readMapBegin()
24086 
          for _i552 in xrange(_size548):
24087 
            _key553 = iprot.readI64();
24088 
            _val554 = iprot.readI64();
24089 
            self.success[_key553] = _val554
5031 varun.gupt 24090 
          iprot.readMapEnd()
24091 
        else:
24092 
          iprot.skip(ftype)
24093 
      elif fid == 1:
24094 
        if ftype == TType.STRUCT:
24095 
          self.ex = TransactionServiceException()
24096 
          self.ex.read(iprot)
24097 
        else:
24098 
          iprot.skip(ftype)
24099 
      else:
24100 
        iprot.skip(ftype)
24101 
      iprot.readFieldEnd()
24102 
    iprot.readStructEnd()
24103 
 
24104 
  def write(self, oprot):
24105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24107 
      return
24108 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24109 
    if self.success is not None:
24110 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24111 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6031 rajveer 24112 
      for kiter555,viter556 in self.success.items():
24113 
        oprot.writeI64(kiter555)
24114 
        oprot.writeI64(viter556)
5031 varun.gupt 24115 
      oprot.writeMapEnd()
24116 
      oprot.writeFieldEnd()
24117 
    if self.ex is not None:
24118 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24119 
      self.ex.write(oprot)
24120 
      oprot.writeFieldEnd()
24121 
    oprot.writeFieldStop()
24122 
    oprot.writeStructEnd()
24123 
 
24124 
  def validate(self):
24125 
    return
24126 
 
24127 
 
24128 
  def __repr__(self):
24129 
    L = ['%s=%r' % (key, value)
24130 
      for key, value in self.__dict__.iteritems()]
24131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24132 
 
24133 
  def __eq__(self, other):
24134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24135 
 
24136 
  def __ne__(self, other):
24137 
    return not (self == other)
5067 varun.gupt 24138 
 
24139 
class getOrderIdsForStatus_args:
24140 
  """
24141 
  Attributes:
24142 
   - status
24143 
   - startDatetime
24144 
   - endDatetime
24145 
  """
24146 
 
24147 
  thrift_spec = (
24148 
    None, # 0
24149 
    (1, TType.I64, 'status', None, None, ), # 1
24150 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24151 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24152 
  )
24153 
 
24154 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24155 
    self.status = status
24156 
    self.startDatetime = startDatetime
24157 
    self.endDatetime = endDatetime
24158 
 
24159 
  def read(self, iprot):
24160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24162 
      return
24163 
    iprot.readStructBegin()
24164 
    while True:
24165 
      (fname, ftype, fid) = iprot.readFieldBegin()
24166 
      if ftype == TType.STOP:
24167 
        break
24168 
      if fid == 1:
24169 
        if ftype == TType.I64:
24170 
          self.status = iprot.readI64();
24171 
        else:
24172 
          iprot.skip(ftype)
24173 
      elif fid == 2:
24174 
        if ftype == TType.I64:
24175 
          self.startDatetime = iprot.readI64();
24176 
        else:
24177 
          iprot.skip(ftype)
24178 
      elif fid == 3:
24179 
        if ftype == TType.I64:
24180 
          self.endDatetime = iprot.readI64();
24181 
        else:
24182 
          iprot.skip(ftype)
24183 
      else:
24184 
        iprot.skip(ftype)
24185 
      iprot.readFieldEnd()
24186 
    iprot.readStructEnd()
24187 
 
24188 
  def write(self, oprot):
24189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24191 
      return
24192 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24193 
    if self.status is not None:
24194 
      oprot.writeFieldBegin('status', TType.I64, 1)
24195 
      oprot.writeI64(self.status)
24196 
      oprot.writeFieldEnd()
24197 
    if self.startDatetime is not None:
24198 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24199 
      oprot.writeI64(self.startDatetime)
24200 
      oprot.writeFieldEnd()
24201 
    if self.endDatetime is not None:
24202 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24203 
      oprot.writeI64(self.endDatetime)
24204 
      oprot.writeFieldEnd()
24205 
    oprot.writeFieldStop()
24206 
    oprot.writeStructEnd()
24207 
 
24208 
  def validate(self):
24209 
    return
24210 
 
24211 
 
24212 
  def __repr__(self):
24213 
    L = ['%s=%r' % (key, value)
24214 
      for key, value in self.__dict__.iteritems()]
24215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24216 
 
24217 
  def __eq__(self, other):
24218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24219 
 
24220 
  def __ne__(self, other):
24221 
    return not (self == other)
24222 
 
24223 
class getOrderIdsForStatus_result:
24224 
  """
24225 
  Attributes:
24226 
   - success
24227 
   - ex
24228 
  """
24229 
 
24230 
  thrift_spec = (
24231 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24233 
  )
24234 
 
24235 
  def __init__(self, success=None, ex=None,):
24236 
    self.success = success
24237 
    self.ex = ex
24238 
 
24239 
  def read(self, iprot):
24240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24242 
      return
24243 
    iprot.readStructBegin()
24244 
    while True:
24245 
      (fname, ftype, fid) = iprot.readFieldBegin()
24246 
      if ftype == TType.STOP:
24247 
        break
24248 
      if fid == 0:
24249 
        if ftype == TType.LIST:
24250 
          self.success = []
6031 rajveer 24251 
          (_etype560, _size557) = iprot.readListBegin()
24252 
          for _i561 in xrange(_size557):
24253 
            _elem562 = iprot.readI64();
24254 
            self.success.append(_elem562)
5067 varun.gupt 24255 
          iprot.readListEnd()
24256 
        else:
24257 
          iprot.skip(ftype)
24258 
      elif fid == 1:
24259 
        if ftype == TType.STRUCT:
24260 
          self.ex = TransactionServiceException()
24261 
          self.ex.read(iprot)
24262 
        else:
24263 
          iprot.skip(ftype)
24264 
      else:
24265 
        iprot.skip(ftype)
24266 
      iprot.readFieldEnd()
24267 
    iprot.readStructEnd()
24268 
 
24269 
  def write(self, oprot):
24270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24272 
      return
24273 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24274 
    if self.success is not None:
24275 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24276 
      oprot.writeListBegin(TType.I64, len(self.success))
6031 rajveer 24277 
      for iter563 in self.success:
24278 
        oprot.writeI64(iter563)
5067 varun.gupt 24279 
      oprot.writeListEnd()
24280 
      oprot.writeFieldEnd()
24281 
    if self.ex is not None:
24282 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24283 
      self.ex.write(oprot)
24284 
      oprot.writeFieldEnd()
24285 
    oprot.writeFieldStop()
24286 
    oprot.writeStructEnd()
24287 
 
24288 
  def validate(self):
24289 
    return
24290 
 
24291 
 
24292 
  def __repr__(self):
24293 
    L = ['%s=%r' % (key, value)
24294 
      for key, value in self.__dict__.iteritems()]
24295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24296 
 
24297 
  def __eq__(self, other):
24298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24299 
 
24300 
  def __ne__(self, other):
24301 
    return not (self == other)
5099 varun.gupt 24302 
 
5348 anupam.sin 24303 
class updateCODAgent_args:
24304 
  """
24305 
  Attributes:
24306 
   - agent
24307 
   - orderId
24308 
  """
24309 
 
24310 
  thrift_spec = (
24311 
    None, # 0
24312 
    (1, TType.STRING, 'agent', None, None, ), # 1
24313 
    (2, TType.I64, 'orderId', None, None, ), # 2
24314 
  )
24315 
 
24316 
  def __init__(self, agent=None, orderId=None,):
24317 
    self.agent = agent
24318 
    self.orderId = orderId
24319 
 
24320 
  def read(self, iprot):
24321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24323 
      return
24324 
    iprot.readStructBegin()
24325 
    while True:
24326 
      (fname, ftype, fid) = iprot.readFieldBegin()
24327 
      if ftype == TType.STOP:
24328 
        break
24329 
      if fid == 1:
24330 
        if ftype == TType.STRING:
24331 
          self.agent = iprot.readString();
24332 
        else:
24333 
          iprot.skip(ftype)
24334 
      elif fid == 2:
24335 
        if ftype == TType.I64:
24336 
          self.orderId = iprot.readI64();
24337 
        else:
24338 
          iprot.skip(ftype)
24339 
      else:
24340 
        iprot.skip(ftype)
24341 
      iprot.readFieldEnd()
24342 
    iprot.readStructEnd()
24343 
 
24344 
  def write(self, oprot):
24345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24347 
      return
24348 
    oprot.writeStructBegin('updateCODAgent_args')
24349 
    if self.agent is not None:
24350 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24351 
      oprot.writeString(self.agent)
24352 
      oprot.writeFieldEnd()
24353 
    if self.orderId is not None:
24354 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24355 
      oprot.writeI64(self.orderId)
24356 
      oprot.writeFieldEnd()
24357 
    oprot.writeFieldStop()
24358 
    oprot.writeStructEnd()
24359 
 
24360 
  def validate(self):
24361 
    return
24362 
 
24363 
 
24364 
  def __repr__(self):
24365 
    L = ['%s=%r' % (key, value)
24366 
      for key, value in self.__dict__.iteritems()]
24367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24368 
 
24369 
  def __eq__(self, other):
24370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24371 
 
24372 
  def __ne__(self, other):
24373 
    return not (self == other)
24374 
 
24375 
class updateCODAgent_result:
24376 
  """
24377 
  Attributes:
24378 
   - ex
24379 
  """
24380 
 
24381 
  thrift_spec = (
24382 
    None, # 0
24383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24384 
  )
24385 
 
24386 
  def __init__(self, ex=None,):
24387 
    self.ex = ex
24388 
 
24389 
  def read(self, iprot):
24390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24392 
      return
24393 
    iprot.readStructBegin()
24394 
    while True:
24395 
      (fname, ftype, fid) = iprot.readFieldBegin()
24396 
      if ftype == TType.STOP:
24397 
        break
24398 
      if fid == 1:
24399 
        if ftype == TType.STRUCT:
24400 
          self.ex = TransactionServiceException()
24401 
          self.ex.read(iprot)
24402 
        else:
24403 
          iprot.skip(ftype)
24404 
      else:
24405 
        iprot.skip(ftype)
24406 
      iprot.readFieldEnd()
24407 
    iprot.readStructEnd()
24408 
 
24409 
  def write(self, oprot):
24410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24412 
      return
24413 
    oprot.writeStructBegin('updateCODAgent_result')
24414 
    if self.ex is not None:
24415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24416 
      self.ex.write(oprot)
24417 
      oprot.writeFieldEnd()
24418 
    oprot.writeFieldStop()
24419 
    oprot.writeStructEnd()
24420 
 
24421 
  def validate(self):
24422 
    return
24423 
 
24424 
 
24425 
  def __repr__(self):
24426 
    L = ['%s=%r' % (key, value)
24427 
      for key, value in self.__dict__.iteritems()]
24428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24429 
 
24430 
  def __eq__(self, other):
24431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24432 
 
24433 
  def __ne__(self, other):
24434 
    return not (self == other)
24435 
 
5099 varun.gupt 24436 
class updateOrderAsPaidToVendor_args:
24437 
  """
24438 
  Attributes:
24439 
   - orderId
24440 
  """
24441 
 
24442 
  thrift_spec = (
24443 
    None, # 0
24444 
    (1, TType.I64, 'orderId', None, None, ), # 1
24445 
  )
24446 
 
24447 
  def __init__(self, orderId=None,):
24448 
    self.orderId = orderId
24449 
 
24450 
  def read(self, iprot):
24451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24453 
      return
24454 
    iprot.readStructBegin()
24455 
    while True:
24456 
      (fname, ftype, fid) = iprot.readFieldBegin()
24457 
      if ftype == TType.STOP:
24458 
        break
24459 
      if fid == 1:
24460 
        if ftype == TType.I64:
24461 
          self.orderId = iprot.readI64();
24462 
        else:
24463 
          iprot.skip(ftype)
24464 
      else:
24465 
        iprot.skip(ftype)
24466 
      iprot.readFieldEnd()
24467 
    iprot.readStructEnd()
24468 
 
24469 
  def write(self, oprot):
24470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24472 
      return
24473 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24474 
    if self.orderId is not None:
24475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24476 
      oprot.writeI64(self.orderId)
24477 
      oprot.writeFieldEnd()
24478 
    oprot.writeFieldStop()
24479 
    oprot.writeStructEnd()
24480 
 
24481 
  def validate(self):
24482 
    return
24483 
 
24484 
 
24485 
  def __repr__(self):
24486 
    L = ['%s=%r' % (key, value)
24487 
      for key, value in self.__dict__.iteritems()]
24488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24489 
 
24490 
  def __eq__(self, other):
24491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24492 
 
24493 
  def __ne__(self, other):
24494 
    return not (self == other)
24495 
 
24496 
class updateOrderAsPaidToVendor_result:
24497 
  """
24498 
  Attributes:
24499 
   - ex
24500 
  """
24501 
 
24502 
  thrift_spec = (
24503 
    None, # 0
24504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24505 
  )
24506 
 
24507 
  def __init__(self, ex=None,):
24508 
    self.ex = ex
24509 
 
24510 
  def read(self, iprot):
24511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24513 
      return
24514 
    iprot.readStructBegin()
24515 
    while True:
24516 
      (fname, ftype, fid) = iprot.readFieldBegin()
24517 
      if ftype == TType.STOP:
24518 
        break
24519 
      if fid == 1:
24520 
        if ftype == TType.STRUCT:
24521 
          self.ex = TransactionServiceException()
24522 
          self.ex.read(iprot)
24523 
        else:
24524 
          iprot.skip(ftype)
24525 
      else:
24526 
        iprot.skip(ftype)
24527 
      iprot.readFieldEnd()
24528 
    iprot.readStructEnd()
24529 
 
24530 
  def write(self, oprot):
24531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24533 
      return
24534 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24535 
    if self.ex is not None:
24536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24537 
      self.ex.write(oprot)
24538 
      oprot.writeFieldEnd()
24539 
    oprot.writeFieldStop()
24540 
    oprot.writeStructEnd()
24541 
 
24542 
  def validate(self):
24543 
    return
24544 
 
24545 
 
24546 
  def __repr__(self):
24547 
    L = ['%s=%r' % (key, value)
24548 
      for key, value in self.__dict__.iteritems()]
24549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24550 
 
24551 
  def __eq__(self, other):
24552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24553 
 
24554 
  def __ne__(self, other):
24555 
    return not (self == other)
5208 varun.gupt 24556 
 
5386 phani.kuma 24557 
class updateOrderOnlyAsPaidToVendor_args:
24558 
  """
24559 
  Attributes:
24560 
   - orderId
24561 
  """
24562 
 
24563 
  thrift_spec = (
24564 
    None, # 0
24565 
    (1, TType.I64, 'orderId', None, None, ), # 1
24566 
  )
24567 
 
24568 
  def __init__(self, orderId=None,):
24569 
    self.orderId = orderId
24570 
 
24571 
  def read(self, iprot):
24572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24574 
      return
24575 
    iprot.readStructBegin()
24576 
    while True:
24577 
      (fname, ftype, fid) = iprot.readFieldBegin()
24578 
      if ftype == TType.STOP:
24579 
        break
24580 
      if fid == 1:
24581 
        if ftype == TType.I64:
24582 
          self.orderId = iprot.readI64();
24583 
        else:
24584 
          iprot.skip(ftype)
24585 
      else:
24586 
        iprot.skip(ftype)
24587 
      iprot.readFieldEnd()
24588 
    iprot.readStructEnd()
24589 
 
24590 
  def write(self, oprot):
24591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24593 
      return
24594 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24595 
    if self.orderId is not None:
24596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24597 
      oprot.writeI64(self.orderId)
24598 
      oprot.writeFieldEnd()
24599 
    oprot.writeFieldStop()
24600 
    oprot.writeStructEnd()
24601 
 
24602 
  def validate(self):
24603 
    return
24604 
 
24605 
 
24606 
  def __repr__(self):
24607 
    L = ['%s=%r' % (key, value)
24608 
      for key, value in self.__dict__.iteritems()]
24609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24610 
 
24611 
  def __eq__(self, other):
24612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24613 
 
24614 
  def __ne__(self, other):
24615 
    return not (self == other)
24616 
 
24617 
class updateOrderOnlyAsPaidToVendor_result:
24618 
  """
24619 
  Attributes:
24620 
   - ex
24621 
  """
24622 
 
24623 
  thrift_spec = (
24624 
    None, # 0
24625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24626 
  )
24627 
 
24628 
  def __init__(self, ex=None,):
24629 
    self.ex = ex
24630 
 
24631 
  def read(self, iprot):
24632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24634 
      return
24635 
    iprot.readStructBegin()
24636 
    while True:
24637 
      (fname, ftype, fid) = iprot.readFieldBegin()
24638 
      if ftype == TType.STOP:
24639 
        break
24640 
      if fid == 1:
24641 
        if ftype == TType.STRUCT:
24642 
          self.ex = TransactionServiceException()
24643 
          self.ex.read(iprot)
24644 
        else:
24645 
          iprot.skip(ftype)
24646 
      else:
24647 
        iprot.skip(ftype)
24648 
      iprot.readFieldEnd()
24649 
    iprot.readStructEnd()
24650 
 
24651 
  def write(self, oprot):
24652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24654 
      return
24655 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24656 
    if self.ex is not None:
24657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24658 
      self.ex.write(oprot)
24659 
      oprot.writeFieldEnd()
24660 
    oprot.writeFieldStop()
24661 
    oprot.writeStructEnd()
24662 
 
24663 
  def validate(self):
24664 
    return
24665 
 
24666 
 
24667 
  def __repr__(self):
24668 
    L = ['%s=%r' % (key, value)
24669 
      for key, value in self.__dict__.iteritems()]
24670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24671 
 
24672 
  def __eq__(self, other):
24673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24674 
 
24675 
  def __ne__(self, other):
24676 
    return not (self == other)
24677 
 
5208 varun.gupt 24678 
class getRefundedOrdersMarkedPaid_args:
24679 
 
24680 
  thrift_spec = (
24681 
  )
24682 
 
24683 
  def read(self, iprot):
24684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24686 
      return
24687 
    iprot.readStructBegin()
24688 
    while True:
24689 
      (fname, ftype, fid) = iprot.readFieldBegin()
24690 
      if ftype == TType.STOP:
24691 
        break
24692 
      else:
24693 
        iprot.skip(ftype)
24694 
      iprot.readFieldEnd()
24695 
    iprot.readStructEnd()
24696 
 
24697 
  def write(self, oprot):
24698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24700 
      return
24701 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24702 
    oprot.writeFieldStop()
24703 
    oprot.writeStructEnd()
24704 
 
24705 
  def validate(self):
24706 
    return
24707 
 
24708 
 
24709 
  def __repr__(self):
24710 
    L = ['%s=%r' % (key, value)
24711 
      for key, value in self.__dict__.iteritems()]
24712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24713 
 
24714 
  def __eq__(self, other):
24715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24716 
 
24717 
  def __ne__(self, other):
24718 
    return not (self == other)
24719 
 
24720 
class getRefundedOrdersMarkedPaid_result:
24721 
  """
24722 
  Attributes:
24723 
   - success
24724 
   - ex
24725 
  """
24726 
 
24727 
  thrift_spec = (
24728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24730 
  )
24731 
 
24732 
  def __init__(self, success=None, ex=None,):
24733 
    self.success = success
24734 
    self.ex = ex
24735 
 
24736 
  def read(self, iprot):
24737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24739 
      return
24740 
    iprot.readStructBegin()
24741 
    while True:
24742 
      (fname, ftype, fid) = iprot.readFieldBegin()
24743 
      if ftype == TType.STOP:
24744 
        break
24745 
      if fid == 0:
24746 
        if ftype == TType.LIST:
24747 
          self.success = []
6031 rajveer 24748 
          (_etype567, _size564) = iprot.readListBegin()
24749 
          for _i568 in xrange(_size564):
24750 
            _elem569 = Order()
24751 
            _elem569.read(iprot)
24752 
            self.success.append(_elem569)
5208 varun.gupt 24753 
          iprot.readListEnd()
24754 
        else:
24755 
          iprot.skip(ftype)
24756 
      elif fid == 1:
24757 
        if ftype == TType.STRUCT:
24758 
          self.ex = TransactionServiceException()
24759 
          self.ex.read(iprot)
24760 
        else:
24761 
          iprot.skip(ftype)
24762 
      else:
24763 
        iprot.skip(ftype)
24764 
      iprot.readFieldEnd()
24765 
    iprot.readStructEnd()
24766 
 
24767 
  def write(self, oprot):
24768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24770 
      return
24771 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
24772 
    if self.success is not None:
24773 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24774 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24775 
      for iter570 in self.success:
24776 
        iter570.write(oprot)
5208 varun.gupt 24777 
      oprot.writeListEnd()
24778 
      oprot.writeFieldEnd()
24779 
    if self.ex is not None:
24780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24781 
      self.ex.write(oprot)
24782 
      oprot.writeFieldEnd()
24783 
    oprot.writeFieldStop()
24784 
    oprot.writeStructEnd()
24785 
 
24786 
  def validate(self):
24787 
    return
24788 
 
24789 
 
24790 
  def __repr__(self):
24791 
    L = ['%s=%r' % (key, value)
24792 
      for key, value in self.__dict__.iteritems()]
24793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24794 
 
24795 
  def __eq__(self, other):
24796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24797 
 
24798 
  def __ne__(self, other):
24799 
    return not (self == other)
5447 anupam.sin 24800 
 
24801 
class getAllVerificationAgents_args:
24802 
  """
24803 
  Attributes:
24804 
   - minOrderId
24805 
   - maxOrderId
24806 
  """
24807 
 
24808 
  thrift_spec = (
24809 
    None, # 0
24810 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
24811 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
24812 
  )
24813 
 
24814 
  def __init__(self, minOrderId=None, maxOrderId=None,):
24815 
    self.minOrderId = minOrderId
24816 
    self.maxOrderId = maxOrderId
24817 
 
24818 
  def read(self, iprot):
24819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24821 
      return
24822 
    iprot.readStructBegin()
24823 
    while True:
24824 
      (fname, ftype, fid) = iprot.readFieldBegin()
24825 
      if ftype == TType.STOP:
24826 
        break
24827 
      if fid == 1:
24828 
        if ftype == TType.I64:
24829 
          self.minOrderId = iprot.readI64();
24830 
        else:
24831 
          iprot.skip(ftype)
24832 
      elif fid == 2:
24833 
        if ftype == TType.I64:
24834 
          self.maxOrderId = iprot.readI64();
24835 
        else:
24836 
          iprot.skip(ftype)
24837 
      else:
24838 
        iprot.skip(ftype)
24839 
      iprot.readFieldEnd()
24840 
    iprot.readStructEnd()
24841 
 
24842 
  def write(self, oprot):
24843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24845 
      return
24846 
    oprot.writeStructBegin('getAllVerificationAgents_args')
24847 
    if self.minOrderId is not None:
24848 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
24849 
      oprot.writeI64(self.minOrderId)
24850 
      oprot.writeFieldEnd()
24851 
    if self.maxOrderId is not None:
24852 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
24853 
      oprot.writeI64(self.maxOrderId)
24854 
      oprot.writeFieldEnd()
24855 
    oprot.writeFieldStop()
24856 
    oprot.writeStructEnd()
24857 
 
24858 
  def validate(self):
24859 
    return
24860 
 
24861 
 
24862 
  def __repr__(self):
24863 
    L = ['%s=%r' % (key, value)
24864 
      for key, value in self.__dict__.iteritems()]
24865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24866 
 
24867 
  def __eq__(self, other):
24868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24869 
 
24870 
  def __ne__(self, other):
24871 
    return not (self == other)
24872 
 
24873 
class getAllVerificationAgents_result:
24874 
  """
24875 
  Attributes:
24876 
   - success
24877 
  """
24878 
 
24879 
  thrift_spec = (
24880 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
24881 
  )
24882 
 
24883 
  def __init__(self, success=None,):
24884 
    self.success = success
24885 
 
24886 
  def read(self, iprot):
24887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24889 
      return
24890 
    iprot.readStructBegin()
24891 
    while True:
24892 
      (fname, ftype, fid) = iprot.readFieldBegin()
24893 
      if ftype == TType.STOP:
24894 
        break
24895 
      if fid == 0:
24896 
        if ftype == TType.LIST:
24897 
          self.success = []
6031 rajveer 24898 
          (_etype574, _size571) = iprot.readListBegin()
24899 
          for _i575 in xrange(_size571):
24900 
            _elem576 = CODVerificationAgent()
24901 
            _elem576.read(iprot)
24902 
            self.success.append(_elem576)
5447 anupam.sin 24903 
          iprot.readListEnd()
24904 
        else:
24905 
          iprot.skip(ftype)
24906 
      else:
24907 
        iprot.skip(ftype)
24908 
      iprot.readFieldEnd()
24909 
    iprot.readStructEnd()
24910 
 
24911 
  def write(self, oprot):
24912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24914 
      return
24915 
    oprot.writeStructBegin('getAllVerificationAgents_result')
24916 
    if self.success is not None:
24917 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24918 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 24919 
      for iter577 in self.success:
24920 
        iter577.write(oprot)
5447 anupam.sin 24921 
      oprot.writeListEnd()
24922 
      oprot.writeFieldEnd()
24923 
    oprot.writeFieldStop()
24924 
    oprot.writeStructEnd()
24925 
 
24926 
  def validate(self):
24927 
    return
24928 
 
24929 
 
24930 
  def __repr__(self):
24931 
    L = ['%s=%r' % (key, value)
24932 
      for key, value in self.__dict__.iteritems()]
24933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24934 
 
24935 
  def __eq__(self, other):
24936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24937 
 
24938 
  def __ne__(self, other):
24939 
    return not (self == other)
5527 anupam.sin 24940 
 
24941 
class getAllAttributesForOrderId_args:
24942 
  """
24943 
  Attributes:
24944 
   - orderId
24945 
  """
24946 
 
24947 
  thrift_spec = (
24948 
    None, # 0
24949 
    (1, TType.I64, 'orderId', None, None, ), # 1
24950 
  )
24951 
 
24952 
  def __init__(self, orderId=None,):
24953 
    self.orderId = orderId
24954 
 
24955 
  def read(self, iprot):
24956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24958 
      return
24959 
    iprot.readStructBegin()
24960 
    while True:
24961 
      (fname, ftype, fid) = iprot.readFieldBegin()
24962 
      if ftype == TType.STOP:
24963 
        break
24964 
      if fid == 1:
24965 
        if ftype == TType.I64:
24966 
          self.orderId = iprot.readI64();
24967 
        else:
24968 
          iprot.skip(ftype)
24969 
      else:
24970 
        iprot.skip(ftype)
24971 
      iprot.readFieldEnd()
24972 
    iprot.readStructEnd()
24973 
 
24974 
  def write(self, oprot):
24975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24977 
      return
24978 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
24979 
    if self.orderId is not None:
24980 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24981 
      oprot.writeI64(self.orderId)
24982 
      oprot.writeFieldEnd()
24983 
    oprot.writeFieldStop()
24984 
    oprot.writeStructEnd()
24985 
 
24986 
  def validate(self):
24987 
    return
24988 
 
24989 
 
24990 
  def __repr__(self):
24991 
    L = ['%s=%r' % (key, value)
24992 
      for key, value in self.__dict__.iteritems()]
24993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24994 
 
24995 
  def __eq__(self, other):
24996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24997 
 
24998 
  def __ne__(self, other):
24999 
    return not (self == other)
25000 
 
25001 
class getAllAttributesForOrderId_result:
25002 
  """
25003 
  Attributes:
25004 
   - success
25005 
  """
25006 
 
25007 
  thrift_spec = (
25008 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25009 
  )
25010 
 
25011 
  def __init__(self, success=None,):
25012 
    self.success = success
25013 
 
25014 
  def read(self, iprot):
25015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25017 
      return
25018 
    iprot.readStructBegin()
25019 
    while True:
25020 
      (fname, ftype, fid) = iprot.readFieldBegin()
25021 
      if ftype == TType.STOP:
25022 
        break
25023 
      if fid == 0:
25024 
        if ftype == TType.LIST:
25025 
          self.success = []
6031 rajveer 25026 
          (_etype581, _size578) = iprot.readListBegin()
25027 
          for _i582 in xrange(_size578):
25028 
            _elem583 = Attribute()
25029 
            _elem583.read(iprot)
25030 
            self.success.append(_elem583)
5527 anupam.sin 25031 
          iprot.readListEnd()
25032 
        else:
25033 
          iprot.skip(ftype)
25034 
      else:
25035 
        iprot.skip(ftype)
25036 
      iprot.readFieldEnd()
25037 
    iprot.readStructEnd()
25038 
 
25039 
  def write(self, oprot):
25040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25042 
      return
25043 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25044 
    if self.success is not None:
25045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25047 
      for iter584 in self.success:
25048 
        iter584.write(oprot)
5527 anupam.sin 25049 
      oprot.writeListEnd()
25050 
      oprot.writeFieldEnd()
25051 
    oprot.writeFieldStop()
25052 
    oprot.writeStructEnd()
25053 
 
25054 
  def validate(self):
25055 
    return
25056 
 
25057 
 
25058 
  def __repr__(self):
25059 
    L = ['%s=%r' % (key, value)
25060 
      for key, value in self.__dict__.iteritems()]
25061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25062 
 
25063 
  def __eq__(self, other):
25064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25065 
 
25066 
  def __ne__(self, other):
25067 
    return not (self == other)
25068 
 
5676 rajveer 25069 
class setOrderAttributes_args:
25070 
  """
25071 
  Attributes:
25072 
   - orderId
25073 
   - attributes
25074 
  """
25075 
 
25076 
  thrift_spec = None
25077 
  def __init__(self, orderId=None, attributes=None,):
25078 
    self.orderId = orderId
25079 
    self.attributes = attributes
25080 
 
25081 
  def read(self, iprot):
25082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25084 
      return
25085 
    iprot.readStructBegin()
25086 
    while True:
25087 
      (fname, ftype, fid) = iprot.readFieldBegin()
25088 
      if ftype == TType.STOP:
25089 
        break
25090 
      if fid == 1:
25091 
        if ftype == TType.I64:
25092 
          self.orderId = iprot.readI64();
25093 
        else:
25094 
          iprot.skip(ftype)
25095 
      elif fid == -1:
25096 
        if ftype == TType.LIST:
25097 
          self.attributes = []
6031 rajveer 25098 
          (_etype588, _size585) = iprot.readListBegin()
25099 
          for _i589 in xrange(_size585):
25100 
            _elem590 = Attribute()
25101 
            _elem590.read(iprot)
25102 
            self.attributes.append(_elem590)
5676 rajveer 25103 
          iprot.readListEnd()
25104 
        else:
25105 
          iprot.skip(ftype)
25106 
      else:
25107 
        iprot.skip(ftype)
25108 
      iprot.readFieldEnd()
25109 
    iprot.readStructEnd()
25110 
 
25111 
  def write(self, oprot):
25112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25114 
      return
25115 
    oprot.writeStructBegin('setOrderAttributes_args')
25116 
    if self.attributes is not None:
25117 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25118 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6031 rajveer 25119 
      for iter591 in self.attributes:
25120 
        iter591.write(oprot)
5676 rajveer 25121 
      oprot.writeListEnd()
25122 
      oprot.writeFieldEnd()
25123 
    if self.orderId is not None:
25124 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25125 
      oprot.writeI64(self.orderId)
25126 
      oprot.writeFieldEnd()
25127 
    oprot.writeFieldStop()
25128 
    oprot.writeStructEnd()
25129 
 
25130 
  def validate(self):
25131 
    return
25132 
 
25133 
 
25134 
  def __repr__(self):
25135 
    L = ['%s=%r' % (key, value)
25136 
      for key, value in self.__dict__.iteritems()]
25137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25138 
 
25139 
  def __eq__(self, other):
25140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25141 
 
25142 
  def __ne__(self, other):
25143 
    return not (self == other)
25144 
 
25145 
class setOrderAttributes_result:
25146 
 
25147 
  thrift_spec = (
25148 
  )
25149 
 
25150 
  def read(self, iprot):
25151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25153 
      return
25154 
    iprot.readStructBegin()
25155 
    while True:
25156 
      (fname, ftype, fid) = iprot.readFieldBegin()
25157 
      if ftype == TType.STOP:
25158 
        break
25159 
      else:
25160 
        iprot.skip(ftype)
25161 
      iprot.readFieldEnd()
25162 
    iprot.readStructEnd()
25163 
 
25164 
  def write(self, oprot):
25165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25167 
      return
25168 
    oprot.writeStructBegin('setOrderAttributes_result')
25169 
    oprot.writeFieldStop()
25170 
    oprot.writeStructEnd()
25171 
 
25172 
  def validate(self):
25173 
    return
25174 
 
25175 
 
25176 
  def __repr__(self):
25177 
    L = ['%s=%r' % (key, value)
25178 
      for key, value in self.__dict__.iteritems()]
25179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25180 
 
25181 
  def __eq__(self, other):
25182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25183 
 
25184 
  def __ne__(self, other):
25185 
    return not (self == other)
25186 
 
5527 anupam.sin 25187 
class setOrderAttributeForTransaction_args:
25188 
  """
25189 
  Attributes:
25190 
   - transactionId
25191 
   - attribute
25192 
  """
25193 
 
25194 
  thrift_spec = None
25195 
  def __init__(self, transactionId=None, attribute=None,):
25196 
    self.transactionId = transactionId
25197 
    self.attribute = attribute
25198 
 
25199 
  def read(self, iprot):
25200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25202 
      return
25203 
    iprot.readStructBegin()
25204 
    while True:
25205 
      (fname, ftype, fid) = iprot.readFieldBegin()
25206 
      if ftype == TType.STOP:
25207 
        break
25208 
      if fid == 1:
25209 
        if ftype == TType.I64:
25210 
          self.transactionId = iprot.readI64();
25211 
        else:
25212 
          iprot.skip(ftype)
25213 
      elif fid == -1:
25214 
        if ftype == TType.STRUCT:
25215 
          self.attribute = Attribute()
25216 
          self.attribute.read(iprot)
25217 
        else:
25218 
          iprot.skip(ftype)
25219 
      else:
25220 
        iprot.skip(ftype)
25221 
      iprot.readFieldEnd()
25222 
    iprot.readStructEnd()
25223 
 
25224 
  def write(self, oprot):
25225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25227 
      return
25228 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25229 
    if self.attribute is not None:
25230 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25231 
      self.attribute.write(oprot)
25232 
      oprot.writeFieldEnd()
25233 
    if self.transactionId is not None:
25234 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25235 
      oprot.writeI64(self.transactionId)
25236 
      oprot.writeFieldEnd()
25237 
    oprot.writeFieldStop()
25238 
    oprot.writeStructEnd()
25239 
 
25240 
  def validate(self):
25241 
    return
25242 
 
25243 
 
25244 
  def __repr__(self):
25245 
    L = ['%s=%r' % (key, value)
25246 
      for key, value in self.__dict__.iteritems()]
25247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25248 
 
25249 
  def __eq__(self, other):
25250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25251 
 
25252 
  def __ne__(self, other):
25253 
    return not (self == other)
25254 
 
25255 
class setOrderAttributeForTransaction_result:
25256 
 
25257 
  thrift_spec = (
25258 
  )
25259 
 
25260 
  def read(self, iprot):
25261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25263 
      return
25264 
    iprot.readStructBegin()
25265 
    while True:
25266 
      (fname, ftype, fid) = iprot.readFieldBegin()
25267 
      if ftype == TType.STOP:
25268 
        break
25269 
      else:
25270 
        iprot.skip(ftype)
25271 
      iprot.readFieldEnd()
25272 
    iprot.readStructEnd()
25273 
 
25274 
  def write(self, oprot):
25275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25277 
      return
25278 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25279 
    oprot.writeFieldStop()
25280 
    oprot.writeStructEnd()
25281 
 
25282 
  def validate(self):
25283 
    return
25284 
 
25285 
 
25286 
  def __repr__(self):
25287 
    L = ['%s=%r' % (key, value)
25288 
      for key, value in self.__dict__.iteritems()]
25289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25290 
 
25291 
  def __eq__(self, other):
25292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25293 
 
25294 
  def __ne__(self, other):
25295 
    return not (self == other)
5553 rajveer 25296 
 
25297 
class getReceivePendingOrders_args:
25298 
  """
25299 
  Attributes:
25300 
   - storeId
25301 
  """
25302 
 
25303 
  thrift_spec = (
25304 
    None, # 0
25305 
    (1, TType.I64, 'storeId', None, None, ), # 1
25306 
  )
25307 
 
25308 
  def __init__(self, storeId=None,):
25309 
    self.storeId = storeId
25310 
 
25311 
  def read(self, iprot):
25312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25314 
      return
25315 
    iprot.readStructBegin()
25316 
    while True:
25317 
      (fname, ftype, fid) = iprot.readFieldBegin()
25318 
      if ftype == TType.STOP:
25319 
        break
25320 
      if fid == 1:
25321 
        if ftype == TType.I64:
25322 
          self.storeId = iprot.readI64();
25323 
        else:
25324 
          iprot.skip(ftype)
25325 
      else:
25326 
        iprot.skip(ftype)
25327 
      iprot.readFieldEnd()
25328 
    iprot.readStructEnd()
25329 
 
25330 
  def write(self, oprot):
25331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25333 
      return
25334 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25335 
    if self.storeId is not None:
25336 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25337 
      oprot.writeI64(self.storeId)
25338 
      oprot.writeFieldEnd()
25339 
    oprot.writeFieldStop()
25340 
    oprot.writeStructEnd()
25341 
 
25342 
  def validate(self):
25343 
    return
25344 
 
25345 
 
25346 
  def __repr__(self):
25347 
    L = ['%s=%r' % (key, value)
25348 
      for key, value in self.__dict__.iteritems()]
25349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25350 
 
25351 
  def __eq__(self, other):
25352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25353 
 
25354 
  def __ne__(self, other):
25355 
    return not (self == other)
25356 
 
25357 
class getReceivePendingOrders_result:
25358 
  """
25359 
  Attributes:
25360 
   - success
25361 
  """
25362 
 
25363 
  thrift_spec = (
25364 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25365 
  )
25366 
 
25367 
  def __init__(self, success=None,):
25368 
    self.success = success
25369 
 
25370 
  def read(self, iprot):
25371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25373 
      return
25374 
    iprot.readStructBegin()
25375 
    while True:
25376 
      (fname, ftype, fid) = iprot.readFieldBegin()
25377 
      if ftype == TType.STOP:
25378 
        break
25379 
      if fid == 0:
25380 
        if ftype == TType.LIST:
25381 
          self.success = []
6031 rajveer 25382 
          (_etype595, _size592) = iprot.readListBegin()
25383 
          for _i596 in xrange(_size592):
25384 
            _elem597 = Order()
25385 
            _elem597.read(iprot)
25386 
            self.success.append(_elem597)
5553 rajveer 25387 
          iprot.readListEnd()
25388 
        else:
25389 
          iprot.skip(ftype)
25390 
      else:
25391 
        iprot.skip(ftype)
25392 
      iprot.readFieldEnd()
25393 
    iprot.readStructEnd()
25394 
 
25395 
  def write(self, oprot):
25396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25398 
      return
25399 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25400 
    if self.success is not None:
25401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25403 
      for iter598 in self.success:
25404 
        iter598.write(oprot)
5553 rajveer 25405 
      oprot.writeListEnd()
25406 
      oprot.writeFieldEnd()
25407 
    oprot.writeFieldStop()
25408 
    oprot.writeStructEnd()
25409 
 
25410 
  def validate(self):
25411 
    return
25412 
 
25413 
 
25414 
  def __repr__(self):
25415 
    L = ['%s=%r' % (key, value)
25416 
      for key, value in self.__dict__.iteritems()]
25417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25418 
 
25419 
  def __eq__(self, other):
25420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25421 
 
25422 
  def __ne__(self, other):
25423 
    return not (self == other)
25424 
 
25425 
class getReceivedAtStoreOrders_args:
25426 
  """
25427 
  Attributes:
25428 
   - storeId
25429 
  """
25430 
 
25431 
  thrift_spec = (
25432 
    None, # 0
25433 
    (1, TType.I64, 'storeId', None, None, ), # 1
25434 
  )
25435 
 
25436 
  def __init__(self, storeId=None,):
25437 
    self.storeId = storeId
25438 
 
25439 
  def read(self, iprot):
25440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25442 
      return
25443 
    iprot.readStructBegin()
25444 
    while True:
25445 
      (fname, ftype, fid) = iprot.readFieldBegin()
25446 
      if ftype == TType.STOP:
25447 
        break
25448 
      if fid == 1:
25449 
        if ftype == TType.I64:
25450 
          self.storeId = iprot.readI64();
25451 
        else:
25452 
          iprot.skip(ftype)
25453 
      else:
25454 
        iprot.skip(ftype)
25455 
      iprot.readFieldEnd()
25456 
    iprot.readStructEnd()
25457 
 
25458 
  def write(self, oprot):
25459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25461 
      return
25462 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25463 
    if self.storeId is not None:
25464 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25465 
      oprot.writeI64(self.storeId)
25466 
      oprot.writeFieldEnd()
25467 
    oprot.writeFieldStop()
25468 
    oprot.writeStructEnd()
25469 
 
25470 
  def validate(self):
25471 
    return
25472 
 
25473 
 
25474 
  def __repr__(self):
25475 
    L = ['%s=%r' % (key, value)
25476 
      for key, value in self.__dict__.iteritems()]
25477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25478 
 
25479 
  def __eq__(self, other):
25480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25481 
 
25482 
  def __ne__(self, other):
25483 
    return not (self == other)
25484 
 
25485 
class getReceivedAtStoreOrders_result:
25486 
  """
25487 
  Attributes:
25488 
   - success
25489 
  """
25490 
 
25491 
  thrift_spec = (
25492 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25493 
  )
25494 
 
25495 
  def __init__(self, success=None,):
25496 
    self.success = success
25497 
 
25498 
  def read(self, iprot):
25499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25501 
      return
25502 
    iprot.readStructBegin()
25503 
    while True:
25504 
      (fname, ftype, fid) = iprot.readFieldBegin()
25505 
      if ftype == TType.STOP:
25506 
        break
25507 
      if fid == 0:
25508 
        if ftype == TType.LIST:
25509 
          self.success = []
6031 rajveer 25510 
          (_etype602, _size599) = iprot.readListBegin()
25511 
          for _i603 in xrange(_size599):
25512 
            _elem604 = Order()
25513 
            _elem604.read(iprot)
25514 
            self.success.append(_elem604)
5553 rajveer 25515 
          iprot.readListEnd()
25516 
        else:
25517 
          iprot.skip(ftype)
25518 
      else:
25519 
        iprot.skip(ftype)
25520 
      iprot.readFieldEnd()
25521 
    iprot.readStructEnd()
25522 
 
25523 
  def write(self, oprot):
25524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25526 
      return
25527 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25528 
    if self.success is not None:
25529 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25530 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25531 
      for iter605 in self.success:
25532 
        iter605.write(oprot)
5553 rajveer 25533 
      oprot.writeListEnd()
25534 
      oprot.writeFieldEnd()
25535 
    oprot.writeFieldStop()
25536 
    oprot.writeStructEnd()
25537 
 
25538 
  def validate(self):
25539 
    return
25540 
 
25541 
 
25542 
  def __repr__(self):
25543 
    L = ['%s=%r' % (key, value)
25544 
      for key, value in self.__dict__.iteritems()]
25545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25546 
 
25547 
  def __eq__(self, other):
25548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25549 
 
25550 
  def __ne__(self, other):
25551 
    return not (self == other)
5593 mandeep.dh 25552 
 
5713 rajveer 25553 
class getOrdersCollectionAtStore_args:
25554 
  """
25555 
  Attributes:
25556 
   - storeId
25557 
   - fromDate
25558 
   - toDate
25559 
   - onlyCod
25560 
  """
25561 
 
25562 
  thrift_spec = (
25563 
    None, # 0
25564 
    (1, TType.I64, 'storeId', None, None, ), # 1
25565 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25566 
    (3, TType.I64, 'toDate', None, None, ), # 3
25567 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25568 
  )
25569 
 
25570 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25571 
    self.storeId = storeId
25572 
    self.fromDate = fromDate
25573 
    self.toDate = toDate
25574 
    self.onlyCod = onlyCod
25575 
 
25576 
  def read(self, iprot):
25577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25579 
      return
25580 
    iprot.readStructBegin()
25581 
    while True:
25582 
      (fname, ftype, fid) = iprot.readFieldBegin()
25583 
      if ftype == TType.STOP:
25584 
        break
25585 
      if fid == 1:
25586 
        if ftype == TType.I64:
25587 
          self.storeId = iprot.readI64();
25588 
        else:
25589 
          iprot.skip(ftype)
25590 
      elif fid == 2:
25591 
        if ftype == TType.I64:
25592 
          self.fromDate = iprot.readI64();
25593 
        else:
25594 
          iprot.skip(ftype)
25595 
      elif fid == 3:
25596 
        if ftype == TType.I64:
25597 
          self.toDate = iprot.readI64();
25598 
        else:
25599 
          iprot.skip(ftype)
25600 
      elif fid == 4:
25601 
        if ftype == TType.BOOL:
25602 
          self.onlyCod = iprot.readBool();
25603 
        else:
25604 
          iprot.skip(ftype)
25605 
      else:
25606 
        iprot.skip(ftype)
25607 
      iprot.readFieldEnd()
25608 
    iprot.readStructEnd()
25609 
 
25610 
  def write(self, oprot):
25611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25613 
      return
25614 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25615 
    if self.storeId is not None:
25616 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25617 
      oprot.writeI64(self.storeId)
25618 
      oprot.writeFieldEnd()
25619 
    if self.fromDate is not None:
25620 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25621 
      oprot.writeI64(self.fromDate)
25622 
      oprot.writeFieldEnd()
25623 
    if self.toDate is not None:
25624 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25625 
      oprot.writeI64(self.toDate)
25626 
      oprot.writeFieldEnd()
25627 
    if self.onlyCod is not None:
25628 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25629 
      oprot.writeBool(self.onlyCod)
25630 
      oprot.writeFieldEnd()
25631 
    oprot.writeFieldStop()
25632 
    oprot.writeStructEnd()
25633 
 
25634 
  def validate(self):
25635 
    return
25636 
 
25637 
 
25638 
  def __repr__(self):
25639 
    L = ['%s=%r' % (key, value)
25640 
      for key, value in self.__dict__.iteritems()]
25641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25642 
 
25643 
  def __eq__(self, other):
25644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25645 
 
25646 
  def __ne__(self, other):
25647 
    return not (self == other)
25648 
 
25649 
class getOrdersCollectionAtStore_result:
25650 
  """
25651 
  Attributes:
25652 
   - success
25653 
  """
25654 
 
25655 
  thrift_spec = (
25656 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25657 
  )
25658 
 
25659 
  def __init__(self, success=None,):
25660 
    self.success = success
25661 
 
25662 
  def read(self, iprot):
25663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25665 
      return
25666 
    iprot.readStructBegin()
25667 
    while True:
25668 
      (fname, ftype, fid) = iprot.readFieldBegin()
25669 
      if ftype == TType.STOP:
25670 
        break
25671 
      if fid == 0:
25672 
        if ftype == TType.LIST:
25673 
          self.success = []
6031 rajveer 25674 
          (_etype609, _size606) = iprot.readListBegin()
25675 
          for _i610 in xrange(_size606):
25676 
            _elem611 = Order()
25677 
            _elem611.read(iprot)
25678 
            self.success.append(_elem611)
5713 rajveer 25679 
          iprot.readListEnd()
25680 
        else:
25681 
          iprot.skip(ftype)
25682 
      else:
25683 
        iprot.skip(ftype)
25684 
      iprot.readFieldEnd()
25685 
    iprot.readStructEnd()
25686 
 
25687 
  def write(self, oprot):
25688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25690 
      return
25691 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25692 
    if self.success is not None:
25693 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25694 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 25695 
      for iter612 in self.success:
25696 
        iter612.write(oprot)
5713 rajveer 25697 
      oprot.writeListEnd()
25698 
      oprot.writeFieldEnd()
25699 
    oprot.writeFieldStop()
25700 
    oprot.writeStructEnd()
25701 
 
25702 
  def validate(self):
25703 
    return
25704 
 
25705 
 
25706 
  def __repr__(self):
25707 
    L = ['%s=%r' % (key, value)
25708 
      for key, value in self.__dict__.iteritems()]
25709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25710 
 
25711 
  def __eq__(self, other):
25712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25713 
 
25714 
  def __ne__(self, other):
25715 
    return not (self == other)
25716 
 
5833 rajveer 25717 
class getOrderAttributeValue_args:
25718 
  """
25719 
  Attributes:
25720 
   - orderId
25721 
   - attributeName
25722 
  """
25723 
 
25724 
  thrift_spec = None
25725 
  def __init__(self, orderId=None, attributeName=None,):
25726 
    self.orderId = orderId
25727 
    self.attributeName = attributeName
25728 
 
25729 
  def read(self, iprot):
25730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25732 
      return
25733 
    iprot.readStructBegin()
25734 
    while True:
25735 
      (fname, ftype, fid) = iprot.readFieldBegin()
25736 
      if ftype == TType.STOP:
25737 
        break
25738 
      if fid == 1:
25739 
        if ftype == TType.I64:
25740 
          self.orderId = iprot.readI64();
25741 
        else:
25742 
          iprot.skip(ftype)
25743 
      elif fid == -1:
25744 
        if ftype == TType.STRING:
25745 
          self.attributeName = iprot.readString();
25746 
        else:
25747 
          iprot.skip(ftype)
25748 
      else:
25749 
        iprot.skip(ftype)
25750 
      iprot.readFieldEnd()
25751 
    iprot.readStructEnd()
25752 
 
25753 
  def write(self, oprot):
25754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25756 
      return
25757 
    oprot.writeStructBegin('getOrderAttributeValue_args')
25758 
    if self.attributeName is not None:
25759 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
25760 
      oprot.writeString(self.attributeName)
25761 
      oprot.writeFieldEnd()
25762 
    if self.orderId is not None:
25763 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25764 
      oprot.writeI64(self.orderId)
25765 
      oprot.writeFieldEnd()
25766 
    oprot.writeFieldStop()
25767 
    oprot.writeStructEnd()
25768 
 
25769 
  def validate(self):
25770 
    return
25771 
 
25772 
 
25773 
  def __repr__(self):
25774 
    L = ['%s=%r' % (key, value)
25775 
      for key, value in self.__dict__.iteritems()]
25776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25777 
 
25778 
  def __eq__(self, other):
25779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25780 
 
25781 
  def __ne__(self, other):
25782 
    return not (self == other)
25783 
 
25784 
class getOrderAttributeValue_result:
25785 
  """
25786 
  Attributes:
25787 
   - success
25788 
  """
25789 
 
25790 
  thrift_spec = (
25791 
    (0, TType.STRING, 'success', None, None, ), # 0
25792 
  )
25793 
 
25794 
  def __init__(self, success=None,):
25795 
    self.success = success
25796 
 
25797 
  def read(self, iprot):
25798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25800 
      return
25801 
    iprot.readStructBegin()
25802 
    while True:
25803 
      (fname, ftype, fid) = iprot.readFieldBegin()
25804 
      if ftype == TType.STOP:
25805 
        break
25806 
      if fid == 0:
25807 
        if ftype == TType.STRING:
25808 
          self.success = iprot.readString();
25809 
        else:
25810 
          iprot.skip(ftype)
25811 
      else:
25812 
        iprot.skip(ftype)
25813 
      iprot.readFieldEnd()
25814 
    iprot.readStructEnd()
25815 
 
25816 
  def write(self, oprot):
25817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25819 
      return
25820 
    oprot.writeStructBegin('getOrderAttributeValue_result')
25821 
    if self.success is not None:
25822 
      oprot.writeFieldBegin('success', TType.STRING, 0)
25823 
      oprot.writeString(self.success)
25824 
      oprot.writeFieldEnd()
25825 
    oprot.writeFieldStop()
25826 
    oprot.writeStructEnd()
25827 
 
25828 
  def validate(self):
25829 
    return
25830 
 
25831 
 
25832 
  def __repr__(self):
25833 
    L = ['%s=%r' % (key, value)
25834 
      for key, value in self.__dict__.iteritems()]
25835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25836 
 
25837 
  def __eq__(self, other):
25838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25839 
 
25840 
  def __ne__(self, other):
25841 
    return not (self == other)
25842 
 
6019 rajveer 25843 
class changeJacketNumber_args:
25844 
  """
25845 
  Attributes:
25846 
   - orderId
25847 
   - jacketNumber
25848 
  """
25849 
 
25850 
  thrift_spec = (
25851 
    None, # 0
25852 
    (1, TType.I64, 'orderId', None, None, ), # 1
25853 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
25854 
  )
25855 
 
25856 
  def __init__(self, orderId=None, jacketNumber=None,):
25857 
    self.orderId = orderId
25858 
    self.jacketNumber = jacketNumber
25859 
 
25860 
  def read(self, iprot):
25861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25863 
      return
25864 
    iprot.readStructBegin()
25865 
    while True:
25866 
      (fname, ftype, fid) = iprot.readFieldBegin()
25867 
      if ftype == TType.STOP:
25868 
        break
25869 
      if fid == 1:
25870 
        if ftype == TType.I64:
25871 
          self.orderId = iprot.readI64();
25872 
        else:
25873 
          iprot.skip(ftype)
25874 
      elif fid == 2:
25875 
        if ftype == TType.I64:
25876 
          self.jacketNumber = iprot.readI64();
25877 
        else:
25878 
          iprot.skip(ftype)
25879 
      else:
25880 
        iprot.skip(ftype)
25881 
      iprot.readFieldEnd()
25882 
    iprot.readStructEnd()
25883 
 
25884 
  def write(self, oprot):
25885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25887 
      return
25888 
    oprot.writeStructBegin('changeJacketNumber_args')
25889 
    if self.orderId is not None:
25890 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25891 
      oprot.writeI64(self.orderId)
25892 
      oprot.writeFieldEnd()
25893 
    if self.jacketNumber is not None:
25894 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
25895 
      oprot.writeI64(self.jacketNumber)
25896 
      oprot.writeFieldEnd()
25897 
    oprot.writeFieldStop()
25898 
    oprot.writeStructEnd()
25899 
 
25900 
  def validate(self):
25901 
    return
25902 
 
25903 
 
25904 
  def __repr__(self):
25905 
    L = ['%s=%r' % (key, value)
25906 
      for key, value in self.__dict__.iteritems()]
25907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25908 
 
25909 
  def __eq__(self, other):
25910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25911 
 
25912 
  def __ne__(self, other):
25913 
    return not (self == other)
25914 
 
25915 
class changeJacketNumber_result:
25916 
  """
25917 
  Attributes:
25918 
   - success
25919 
  """
25920 
 
25921 
  thrift_spec = (
25922 
    (0, TType.BOOL, 'success', None, None, ), # 0
25923 
  )
25924 
 
25925 
  def __init__(self, success=None,):
25926 
    self.success = success
25927 
 
25928 
  def read(self, iprot):
25929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25931 
      return
25932 
    iprot.readStructBegin()
25933 
    while True:
25934 
      (fname, ftype, fid) = iprot.readFieldBegin()
25935 
      if ftype == TType.STOP:
25936 
        break
25937 
      if fid == 0:
25938 
        if ftype == TType.BOOL:
25939 
          self.success = iprot.readBool();
25940 
        else:
25941 
          iprot.skip(ftype)
25942 
      else:
25943 
        iprot.skip(ftype)
25944 
      iprot.readFieldEnd()
25945 
    iprot.readStructEnd()
25946 
 
25947 
  def write(self, oprot):
25948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25950 
      return
25951 
    oprot.writeStructBegin('changeJacketNumber_result')
25952 
    if self.success is not None:
25953 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
25954 
      oprot.writeBool(self.success)
25955 
      oprot.writeFieldEnd()
25956 
    oprot.writeFieldStop()
25957 
    oprot.writeStructEnd()
25958 
 
25959 
  def validate(self):
25960 
    return
25961 
 
25962 
 
25963 
  def __repr__(self):
25964 
    L = ['%s=%r' % (key, value)
25965 
      for key, value in self.__dict__.iteritems()]
25966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25967 
 
25968 
  def __eq__(self, other):
25969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25970 
 
25971 
  def __ne__(self, other):
25972 
    return not (self == other)
25973 
 
25974 
class markOrderAsRtoInTransit_args:
25975 
  """
25976 
  Attributes:
25977 
   - orderId
25978 
  """
25979 
 
25980 
  thrift_spec = (
25981 
    None, # 0
25982 
    (1, TType.I64, 'orderId', None, None, ), # 1
25983 
  )
25984 
 
25985 
  def __init__(self, orderId=None,):
25986 
    self.orderId = orderId
25987 
 
25988 
  def read(self, iprot):
25989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25991 
      return
25992 
    iprot.readStructBegin()
25993 
    while True:
25994 
      (fname, ftype, fid) = iprot.readFieldBegin()
25995 
      if ftype == TType.STOP:
25996 
        break
25997 
      if fid == 1:
25998 
        if ftype == TType.I64:
25999 
          self.orderId = iprot.readI64();
26000 
        else:
26001 
          iprot.skip(ftype)
26002 
      else:
26003 
        iprot.skip(ftype)
26004 
      iprot.readFieldEnd()
26005 
    iprot.readStructEnd()
26006 
 
26007 
  def write(self, oprot):
26008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26010 
      return
26011 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26012 
    if self.orderId is not None:
26013 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26014 
      oprot.writeI64(self.orderId)
26015 
      oprot.writeFieldEnd()
26016 
    oprot.writeFieldStop()
26017 
    oprot.writeStructEnd()
26018 
 
26019 
  def validate(self):
26020 
    return
26021 
 
26022 
 
26023 
  def __repr__(self):
26024 
    L = ['%s=%r' % (key, value)
26025 
      for key, value in self.__dict__.iteritems()]
26026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26027 
 
26028 
  def __eq__(self, other):
26029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26030 
 
26031 
  def __ne__(self, other):
26032 
    return not (self == other)
26033 
 
26034 
class markOrderAsRtoInTransit_result:
26035 
  """
26036 
  Attributes:
26037 
   - success
26038 
  """
26039 
 
26040 
  thrift_spec = (
26041 
    (0, TType.BOOL, 'success', None, None, ), # 0
26042 
  )
26043 
 
26044 
  def __init__(self, success=None,):
26045 
    self.success = success
26046 
 
26047 
  def read(self, iprot):
26048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26050 
      return
26051 
    iprot.readStructBegin()
26052 
    while True:
26053 
      (fname, ftype, fid) = iprot.readFieldBegin()
26054 
      if ftype == TType.STOP:
26055 
        break
26056 
      if fid == 0:
26057 
        if ftype == TType.BOOL:
26058 
          self.success = iprot.readBool();
26059 
        else:
26060 
          iprot.skip(ftype)
26061 
      else:
26062 
        iprot.skip(ftype)
26063 
      iprot.readFieldEnd()
26064 
    iprot.readStructEnd()
26065 
 
26066 
  def write(self, oprot):
26067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26069 
      return
26070 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26071 
    if self.success is not None:
26072 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26073 
      oprot.writeBool(self.success)
26074 
      oprot.writeFieldEnd()
26075 
    oprot.writeFieldStop()
26076 
    oprot.writeStructEnd()
26077 
 
26078 
  def validate(self):
26079 
    return
26080 
 
26081 
 
26082 
  def __repr__(self):
26083 
    L = ['%s=%r' % (key, value)
26084 
      for key, value in self.__dict__.iteritems()]
26085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26086 
 
26087 
  def __eq__(self, other):
26088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26089 
 
26090 
  def __ne__(self, other):
26091 
    return not (self == other)
26092 
 
5593 mandeep.dh 26093 
class acceptOrderForItem_args:
26094 
  """
26095 
  Attributes:
26096 
   - itemId
26097 
   - quantity
26098 
   - fulfilmentWarehouseId
26099 
   - billingWarehouseId
26100 
  """
26101 
 
26102 
  thrift_spec = (
26103 
    None, # 0
26104 
    (1, TType.I64, 'itemId', None, None, ), # 1
26105 
    (2, TType.I64, 'quantity', None, None, ), # 2
26106 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26107 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26108 
  )
26109 
 
26110 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26111 
    self.itemId = itemId
26112 
    self.quantity = quantity
26113 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26114 
    self.billingWarehouseId = billingWarehouseId
26115 
 
26116 
  def read(self, iprot):
26117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26119 
      return
26120 
    iprot.readStructBegin()
26121 
    while True:
26122 
      (fname, ftype, fid) = iprot.readFieldBegin()
26123 
      if ftype == TType.STOP:
26124 
        break
26125 
      if fid == 1:
26126 
        if ftype == TType.I64:
26127 
          self.itemId = iprot.readI64();
26128 
        else:
26129 
          iprot.skip(ftype)
26130 
      elif fid == 2:
26131 
        if ftype == TType.I64:
26132 
          self.quantity = iprot.readI64();
26133 
        else:
26134 
          iprot.skip(ftype)
26135 
      elif fid == 3:
26136 
        if ftype == TType.I64:
26137 
          self.fulfilmentWarehouseId = iprot.readI64();
26138 
        else:
26139 
          iprot.skip(ftype)
26140 
      elif fid == 4:
26141 
        if ftype == TType.I64:
26142 
          self.billingWarehouseId = iprot.readI64();
26143 
        else:
26144 
          iprot.skip(ftype)
26145 
      else:
26146 
        iprot.skip(ftype)
26147 
      iprot.readFieldEnd()
26148 
    iprot.readStructEnd()
26149 
 
26150 
  def write(self, oprot):
26151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26153 
      return
26154 
    oprot.writeStructBegin('acceptOrderForItem_args')
26155 
    if self.itemId is not None:
26156 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26157 
      oprot.writeI64(self.itemId)
26158 
      oprot.writeFieldEnd()
26159 
    if self.quantity is not None:
26160 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26161 
      oprot.writeI64(self.quantity)
26162 
      oprot.writeFieldEnd()
26163 
    if self.fulfilmentWarehouseId is not None:
26164 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26165 
      oprot.writeI64(self.fulfilmentWarehouseId)
26166 
      oprot.writeFieldEnd()
26167 
    if self.billingWarehouseId is not None:
26168 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26169 
      oprot.writeI64(self.billingWarehouseId)
26170 
      oprot.writeFieldEnd()
26171 
    oprot.writeFieldStop()
26172 
    oprot.writeStructEnd()
26173 
 
26174 
  def validate(self):
26175 
    return
26176 
 
26177 
 
26178 
  def __repr__(self):
26179 
    L = ['%s=%r' % (key, value)
26180 
      for key, value in self.__dict__.iteritems()]
26181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26182 
 
26183 
  def __eq__(self, other):
26184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26185 
 
26186 
  def __ne__(self, other):
26187 
    return not (self == other)
26188 
 
26189 
class acceptOrderForItem_result:
26190 
 
26191 
  thrift_spec = (
26192 
  )
26193 
 
26194 
  def read(self, iprot):
26195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26197 
      return
26198 
    iprot.readStructBegin()
26199 
    while True:
26200 
      (fname, ftype, fid) = iprot.readFieldBegin()
26201 
      if ftype == TType.STOP:
26202 
        break
26203 
      else:
26204 
        iprot.skip(ftype)
26205 
      iprot.readFieldEnd()
26206 
    iprot.readStructEnd()
26207 
 
26208 
  def write(self, oprot):
26209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26211 
      return
26212 
    oprot.writeStructBegin('acceptOrderForItem_result')
26213 
    oprot.writeFieldStop()
26214 
    oprot.writeStructEnd()
26215 
 
26216 
  def validate(self):
26217 
    return
26218 
 
26219 
 
26220 
  def __repr__(self):
26221 
    L = ['%s=%r' % (key, value)
26222 
      for key, value in self.__dict__.iteritems()]
26223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26224 
 
26225 
  def __eq__(self, other):
26226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26227 
 
26228 
  def __ne__(self, other):
26229 
    return not (self == other)
6000 mandeep.dh 26230 
 
26231 
class createRechargeOrder_args:
26232 
  """
26233 
  Attributes:
26234 
   - rechargeOrder
26235 
  """
26236 
 
26237 
  thrift_spec = (
26238 
    None, # 0
26239 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26240 
  )
26241 
 
26242 
  def __init__(self, rechargeOrder=None,):
26243 
    self.rechargeOrder = rechargeOrder
26244 
 
26245 
  def read(self, iprot):
26246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26248 
      return
26249 
    iprot.readStructBegin()
26250 
    while True:
26251 
      (fname, ftype, fid) = iprot.readFieldBegin()
26252 
      if ftype == TType.STOP:
26253 
        break
26254 
      if fid == 1:
26255 
        if ftype == TType.STRUCT:
26256 
          self.rechargeOrder = RechargeOrder()
26257 
          self.rechargeOrder.read(iprot)
26258 
        else:
26259 
          iprot.skip(ftype)
26260 
      else:
26261 
        iprot.skip(ftype)
26262 
      iprot.readFieldEnd()
26263 
    iprot.readStructEnd()
26264 
 
26265 
  def write(self, oprot):
26266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26268 
      return
26269 
    oprot.writeStructBegin('createRechargeOrder_args')
26270 
    if self.rechargeOrder is not None:
26271 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26272 
      self.rechargeOrder.write(oprot)
26273 
      oprot.writeFieldEnd()
26274 
    oprot.writeFieldStop()
26275 
    oprot.writeStructEnd()
26276 
 
26277 
  def validate(self):
26278 
    return
26279 
 
26280 
 
26281 
  def __repr__(self):
26282 
    L = ['%s=%r' % (key, value)
26283 
      for key, value in self.__dict__.iteritems()]
26284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26285 
 
26286 
  def __eq__(self, other):
26287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26288 
 
26289 
  def __ne__(self, other):
26290 
    return not (self == other)
26291 
 
26292 
class createRechargeOrder_result:
26293 
  """
26294 
  Attributes:
26295 
   - success
26296 
   - ex
26297 
  """
26298 
 
26299 
  thrift_spec = (
26300 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26302 
  )
26303 
 
26304 
  def __init__(self, success=None, ex=None,):
26305 
    self.success = success
26306 
    self.ex = ex
26307 
 
26308 
  def read(self, iprot):
26309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26311 
      return
26312 
    iprot.readStructBegin()
26313 
    while True:
26314 
      (fname, ftype, fid) = iprot.readFieldBegin()
26315 
      if ftype == TType.STOP:
26316 
        break
26317 
      if fid == 0:
26318 
        if ftype == TType.STRUCT:
26319 
          self.success = RechargeOrder()
26320 
          self.success.read(iprot)
26321 
        else:
26322 
          iprot.skip(ftype)
26323 
      elif fid == 1:
26324 
        if ftype == TType.STRUCT:
26325 
          self.ex = TransactionServiceException()
26326 
          self.ex.read(iprot)
26327 
        else:
26328 
          iprot.skip(ftype)
26329 
      else:
26330 
        iprot.skip(ftype)
26331 
      iprot.readFieldEnd()
26332 
    iprot.readStructEnd()
26333 
 
26334 
  def write(self, oprot):
26335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26337 
      return
26338 
    oprot.writeStructBegin('createRechargeOrder_result')
26339 
    if self.success is not None:
26340 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26341 
      self.success.write(oprot)
26342 
      oprot.writeFieldEnd()
26343 
    if self.ex is not None:
26344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26345 
      self.ex.write(oprot)
26346 
      oprot.writeFieldEnd()
26347 
    oprot.writeFieldStop()
26348 
    oprot.writeStructEnd()
26349 
 
26350 
  def validate(self):
26351 
    return
26352 
 
26353 
 
26354 
  def __repr__(self):
26355 
    L = ['%s=%r' % (key, value)
26356 
      for key, value in self.__dict__.iteritems()]
26357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26358 
 
26359 
  def __eq__(self, other):
26360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26361 
 
26362 
  def __ne__(self, other):
26363 
    return not (self == other)
26364 
 
6031 rajveer 26365 
class getRechargeOrder_args:
26366 
  """
26367 
  Attributes:
26368 
   - rechargeRrderId
26369 
  """
26370 
 
26371 
  thrift_spec = (
26372 
    None, # 0
26373 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26374 
  )
26375 
 
26376 
  def __init__(self, rechargeRrderId=None,):
26377 
    self.rechargeRrderId = rechargeRrderId
26378 
 
26379 
  def read(self, iprot):
26380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26382 
      return
26383 
    iprot.readStructBegin()
26384 
    while True:
26385 
      (fname, ftype, fid) = iprot.readFieldBegin()
26386 
      if ftype == TType.STOP:
26387 
        break
26388 
      if fid == 1:
26389 
        if ftype == TType.I64:
26390 
          self.rechargeRrderId = iprot.readI64();
26391 
        else:
26392 
          iprot.skip(ftype)
26393 
      else:
26394 
        iprot.skip(ftype)
26395 
      iprot.readFieldEnd()
26396 
    iprot.readStructEnd()
26397 
 
26398 
  def write(self, oprot):
26399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26401 
      return
26402 
    oprot.writeStructBegin('getRechargeOrder_args')
26403 
    if self.rechargeRrderId is not None:
26404 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26405 
      oprot.writeI64(self.rechargeRrderId)
26406 
      oprot.writeFieldEnd()
26407 
    oprot.writeFieldStop()
26408 
    oprot.writeStructEnd()
26409 
 
26410 
  def validate(self):
26411 
    return
26412 
 
26413 
 
26414 
  def __repr__(self):
26415 
    L = ['%s=%r' % (key, value)
26416 
      for key, value in self.__dict__.iteritems()]
26417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26418 
 
26419 
  def __eq__(self, other):
26420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26421 
 
26422 
  def __ne__(self, other):
26423 
    return not (self == other)
26424 
 
26425 
class getRechargeOrder_result:
26426 
  """
26427 
  Attributes:
26428 
   - success
26429 
   - ex
26430 
  """
26431 
 
26432 
  thrift_spec = (
26433 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26435 
  )
26436 
 
26437 
  def __init__(self, success=None, ex=None,):
26438 
    self.success = success
26439 
    self.ex = ex
26440 
 
26441 
  def read(self, iprot):
26442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26444 
      return
26445 
    iprot.readStructBegin()
26446 
    while True:
26447 
      (fname, ftype, fid) = iprot.readFieldBegin()
26448 
      if ftype == TType.STOP:
26449 
        break
26450 
      if fid == 0:
26451 
        if ftype == TType.STRUCT:
26452 
          self.success = RechargeOrder()
26453 
          self.success.read(iprot)
26454 
        else:
26455 
          iprot.skip(ftype)
26456 
      elif fid == 1:
26457 
        if ftype == TType.STRUCT:
26458 
          self.ex = TransactionServiceException()
26459 
          self.ex.read(iprot)
26460 
        else:
26461 
          iprot.skip(ftype)
26462 
      else:
26463 
        iprot.skip(ftype)
26464 
      iprot.readFieldEnd()
26465 
    iprot.readStructEnd()
26466 
 
26467 
  def write(self, oprot):
26468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26470 
      return
26471 
    oprot.writeStructBegin('getRechargeOrder_result')
26472 
    if self.success is not None:
26473 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26474 
      self.success.write(oprot)
26475 
      oprot.writeFieldEnd()
26476 
    if self.ex is not None:
26477 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26478 
      self.ex.write(oprot)
26479 
      oprot.writeFieldEnd()
26480 
    oprot.writeFieldStop()
26481 
    oprot.writeStructEnd()
26482 
 
26483 
  def validate(self):
26484 
    return
26485 
 
26486 
 
26487 
  def __repr__(self):
26488 
    L = ['%s=%r' % (key, value)
26489 
      for key, value in self.__dict__.iteritems()]
26490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26491 
 
26492 
  def __eq__(self, other):
26493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26494 
 
26495 
  def __ne__(self, other):
26496 
    return not (self == other)
26497 
 
26498 
class getRechargeOrders_args:
26499 
  """
26500 
  Attributes:
26501 
   - userId
26502 
  """
26503 
 
26504 
  thrift_spec = (
26505 
    None, # 0
26506 
    (1, TType.I64, 'userId', None, None, ), # 1
26507 
  )
26508 
 
26509 
  def __init__(self, userId=None,):
26510 
    self.userId = userId
26511 
 
26512 
  def read(self, iprot):
26513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26515 
      return
26516 
    iprot.readStructBegin()
26517 
    while True:
26518 
      (fname, ftype, fid) = iprot.readFieldBegin()
26519 
      if ftype == TType.STOP:
26520 
        break
26521 
      if fid == 1:
26522 
        if ftype == TType.I64:
26523 
          self.userId = iprot.readI64();
26524 
        else:
26525 
          iprot.skip(ftype)
26526 
      else:
26527 
        iprot.skip(ftype)
26528 
      iprot.readFieldEnd()
26529 
    iprot.readStructEnd()
26530 
 
26531 
  def write(self, oprot):
26532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26534 
      return
26535 
    oprot.writeStructBegin('getRechargeOrders_args')
26536 
    if self.userId is not None:
26537 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26538 
      oprot.writeI64(self.userId)
26539 
      oprot.writeFieldEnd()
26540 
    oprot.writeFieldStop()
26541 
    oprot.writeStructEnd()
26542 
 
26543 
  def validate(self):
26544 
    return
26545 
 
26546 
 
26547 
  def __repr__(self):
26548 
    L = ['%s=%r' % (key, value)
26549 
      for key, value in self.__dict__.iteritems()]
26550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26551 
 
26552 
  def __eq__(self, other):
26553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26554 
 
26555 
  def __ne__(self, other):
26556 
    return not (self == other)
26557 
 
26558 
class getRechargeOrders_result:
26559 
  """
26560 
  Attributes:
26561 
   - success
26562 
  """
26563 
 
26564 
  thrift_spec = (
26565 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26566 
  )
26567 
 
26568 
  def __init__(self, success=None,):
26569 
    self.success = success
26570 
 
26571 
  def read(self, iprot):
26572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26574 
      return
26575 
    iprot.readStructBegin()
26576 
    while True:
26577 
      (fname, ftype, fid) = iprot.readFieldBegin()
26578 
      if ftype == TType.STOP:
26579 
        break
26580 
      if fid == 0:
26581 
        if ftype == TType.LIST:
26582 
          self.success = []
26583 
          (_etype616, _size613) = iprot.readListBegin()
26584 
          for _i617 in xrange(_size613):
26585 
            _elem618 = RechargeOrder()
26586 
            _elem618.read(iprot)
26587 
            self.success.append(_elem618)
26588 
          iprot.readListEnd()
26589 
        else:
26590 
          iprot.skip(ftype)
26591 
      else:
26592 
        iprot.skip(ftype)
26593 
      iprot.readFieldEnd()
26594 
    iprot.readStructEnd()
26595 
 
26596 
  def write(self, oprot):
26597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26599 
      return
26600 
    oprot.writeStructBegin('getRechargeOrders_result')
26601 
    if self.success is not None:
26602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
26604 
      for iter619 in self.success:
26605 
        iter619.write(oprot)
26606 
      oprot.writeListEnd()
26607 
      oprot.writeFieldEnd()
26608 
    oprot.writeFieldStop()
26609 
    oprot.writeStructEnd()
26610 
 
26611 
  def validate(self):
26612 
    return
26613 
 
26614 
 
26615 
  def __repr__(self):
26616 
    L = ['%s=%r' % (key, value)
26617 
      for key, value in self.__dict__.iteritems()]
26618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26619 
 
26620 
  def __eq__(self, other):
26621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26622 
 
26623 
  def __ne__(self, other):
26624 
    return not (self == other)
26625 
 
6000 mandeep.dh 26626 
class updateRechargeOrderStatus_args:
26627 
  """
26628 
  Attributes:
26629 
   - rechargeOrderId
26630 
   - rechargeOrderStatus
26631 
  """
26632 
 
26633 
  thrift_spec = (
26634 
    None, # 0
26635 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26636 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26637 
  )
26638 
 
26639 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26640 
    self.rechargeOrderId = rechargeOrderId
26641 
    self.rechargeOrderStatus = rechargeOrderStatus
26642 
 
26643 
  def read(self, iprot):
26644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26646 
      return
26647 
    iprot.readStructBegin()
26648 
    while True:
26649 
      (fname, ftype, fid) = iprot.readFieldBegin()
26650 
      if ftype == TType.STOP:
26651 
        break
26652 
      if fid == 1:
26653 
        if ftype == TType.I64:
26654 
          self.rechargeOrderId = iprot.readI64();
26655 
        else:
26656 
          iprot.skip(ftype)
26657 
      elif fid == 2:
26658 
        if ftype == TType.I32:
26659 
          self.rechargeOrderStatus = iprot.readI32();
26660 
        else:
26661 
          iprot.skip(ftype)
26662 
      else:
26663 
        iprot.skip(ftype)
26664 
      iprot.readFieldEnd()
26665 
    iprot.readStructEnd()
26666 
 
26667 
  def write(self, oprot):
26668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26670 
      return
26671 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26672 
    if self.rechargeOrderId is not None:
26673 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26674 
      oprot.writeI64(self.rechargeOrderId)
26675 
      oprot.writeFieldEnd()
26676 
    if self.rechargeOrderStatus is not None:
26677 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26678 
      oprot.writeI32(self.rechargeOrderStatus)
26679 
      oprot.writeFieldEnd()
26680 
    oprot.writeFieldStop()
26681 
    oprot.writeStructEnd()
26682 
 
26683 
  def validate(self):
26684 
    return
26685 
 
26686 
 
26687 
  def __repr__(self):
26688 
    L = ['%s=%r' % (key, value)
26689 
      for key, value in self.__dict__.iteritems()]
26690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26691 
 
26692 
  def __eq__(self, other):
26693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26694 
 
26695 
  def __ne__(self, other):
26696 
    return not (self == other)
26697 
 
26698 
class updateRechargeOrderStatus_result:
26699 
  """
26700 
  Attributes:
6031 rajveer 26701 
   - success
6000 mandeep.dh 26702 
   - ex
26703 
  """
26704 
 
26705 
  thrift_spec = (
6031 rajveer 26706 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26707 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26708 
  )
26709 
 
6031 rajveer 26710 
  def __init__(self, success=None, ex=None,):
26711 
    self.success = success
6000 mandeep.dh 26712 
    self.ex = ex
26713 
 
26714 
  def read(self, iprot):
26715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26717 
      return
26718 
    iprot.readStructBegin()
26719 
    while True:
26720 
      (fname, ftype, fid) = iprot.readFieldBegin()
26721 
      if ftype == TType.STOP:
26722 
        break
6031 rajveer 26723 
      if fid == 0:
26724 
        if ftype == TType.BOOL:
26725 
          self.success = iprot.readBool();
26726 
        else:
26727 
          iprot.skip(ftype)
26728 
      elif fid == 1:
6000 mandeep.dh 26729 
        if ftype == TType.STRUCT:
26730 
          self.ex = TransactionServiceException()
26731 
          self.ex.read(iprot)
26732 
        else:
26733 
          iprot.skip(ftype)
26734 
      else:
26735 
        iprot.skip(ftype)
26736 
      iprot.readFieldEnd()
26737 
    iprot.readStructEnd()
26738 
 
26739 
  def write(self, oprot):
26740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26742 
      return
26743 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 26744 
    if self.success is not None:
26745 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26746 
      oprot.writeBool(self.success)
26747 
      oprot.writeFieldEnd()
6000 mandeep.dh 26748 
    if self.ex is not None:
26749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26750 
      self.ex.write(oprot)
26751 
      oprot.writeFieldEnd()
26752 
    oprot.writeFieldStop()
26753 
    oprot.writeStructEnd()
26754 
 
26755 
  def validate(self):
26756 
    return
26757 
 
26758 
 
26759 
  def __repr__(self):
26760 
    L = ['%s=%r' % (key, value)
26761 
      for key, value in self.__dict__.iteritems()]
26762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26763 
 
26764 
  def __eq__(self, other):
26765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26766 
 
26767 
  def __ne__(self, other):
26768 
    return not (self == other)
26769 
 
26770 
class activateRechargeTxn_args:
26771 
  """
26772 
  Attributes:
6031 rajveer 26773 
   - rechargeOrderId
6000 mandeep.dh 26774 
  """
26775 
 
26776 
  thrift_spec = (
26777 
    None, # 0
6031 rajveer 26778 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 26779 
  )
26780 
 
6031 rajveer 26781 
  def __init__(self, rechargeOrderId=None,):
26782 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 26783 
 
26784 
  def read(self, iprot):
26785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26787 
      return
26788 
    iprot.readStructBegin()
26789 
    while True:
26790 
      (fname, ftype, fid) = iprot.readFieldBegin()
26791 
      if ftype == TType.STOP:
26792 
        break
26793 
      if fid == 1:
6031 rajveer 26794 
        if ftype == TType.I64:
26795 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 26796 
        else:
26797 
          iprot.skip(ftype)
26798 
      else:
26799 
        iprot.skip(ftype)
26800 
      iprot.readFieldEnd()
26801 
    iprot.readStructEnd()
26802 
 
26803 
  def write(self, oprot):
26804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26806 
      return
26807 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 26808 
    if self.rechargeOrderId is not None:
26809 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26810 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 26811 
      oprot.writeFieldEnd()
26812 
    oprot.writeFieldStop()
26813 
    oprot.writeStructEnd()
26814 
 
26815 
  def validate(self):
26816 
    return
26817 
 
26818 
 
26819 
  def __repr__(self):
26820 
    L = ['%s=%r' % (key, value)
26821 
      for key, value in self.__dict__.iteritems()]
26822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26823 
 
26824 
  def __eq__(self, other):
26825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26826 
 
26827 
  def __ne__(self, other):
26828 
    return not (self == other)
26829 
 
26830 
class activateRechargeTxn_result:
26831 
  """
26832 
  Attributes:
26833 
   - success
26834 
   - ex
26835 
  """
26836 
 
26837 
  thrift_spec = (
6031 rajveer 26838 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26840 
  )
26841 
 
26842 
  def __init__(self, success=None, ex=None,):
26843 
    self.success = success
26844 
    self.ex = ex
26845 
 
26846 
  def read(self, iprot):
26847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26849 
      return
26850 
    iprot.readStructBegin()
26851 
    while True:
26852 
      (fname, ftype, fid) = iprot.readFieldBegin()
26853 
      if ftype == TType.STOP:
26854 
        break
26855 
      if fid == 0:
6031 rajveer 26856 
        if ftype == TType.BOOL:
26857 
          self.success = iprot.readBool();
6000 mandeep.dh 26858 
        else:
26859 
          iprot.skip(ftype)
26860 
      elif fid == 1:
26861 
        if ftype == TType.STRUCT:
26862 
          self.ex = TransactionServiceException()
26863 
          self.ex.read(iprot)
26864 
        else:
26865 
          iprot.skip(ftype)
26866 
      else:
26867 
        iprot.skip(ftype)
26868 
      iprot.readFieldEnd()
26869 
    iprot.readStructEnd()
26870 
 
26871 
  def write(self, oprot):
26872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26874 
      return
26875 
    oprot.writeStructBegin('activateRechargeTxn_result')
26876 
    if self.success is not None:
6031 rajveer 26877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26878 
      oprot.writeBool(self.success)
6000 mandeep.dh 26879 
      oprot.writeFieldEnd()
26880 
    if self.ex is not None:
26881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26882 
      self.ex.write(oprot)
26883 
      oprot.writeFieldEnd()
26884 
    oprot.writeFieldStop()
26885 
    oprot.writeStructEnd()
26886 
 
26887 
  def validate(self):
26888 
    return
26889 
 
26890 
 
26891 
  def __repr__(self):
26892 
    L = ['%s=%r' % (key, value)
26893 
      for key, value in self.__dict__.iteritems()]
26894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26895 
 
26896 
  def __eq__(self, other):
26897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26898 
 
26899 
  def __ne__(self, other):
26900 
    return not (self == other)
26901 
 
6031 rajveer 26902 
class getUserWallet_args:
6000 mandeep.dh 26903 
  """
26904 
  Attributes:
6031 rajveer 26905 
   - userId
6000 mandeep.dh 26906 
  """
26907 
 
26908 
  thrift_spec = (
26909 
    None, # 0
6031 rajveer 26910 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 26911 
  )
26912 
 
6031 rajveer 26913 
  def __init__(self, userId=None,):
26914 
    self.userId = userId
6000 mandeep.dh 26915 
 
26916 
  def read(self, iprot):
26917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26919 
      return
26920 
    iprot.readStructBegin()
26921 
    while True:
26922 
      (fname, ftype, fid) = iprot.readFieldBegin()
26923 
      if ftype == TType.STOP:
26924 
        break
26925 
      if fid == 1:
26926 
        if ftype == TType.I64:
6031 rajveer 26927 
          self.userId = iprot.readI64();
6000 mandeep.dh 26928 
        else:
26929 
          iprot.skip(ftype)
26930 
      else:
26931 
        iprot.skip(ftype)
26932 
      iprot.readFieldEnd()
26933 
    iprot.readStructEnd()
26934 
 
26935 
  def write(self, oprot):
26936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26938 
      return
6031 rajveer 26939 
    oprot.writeStructBegin('getUserWallet_args')
26940 
    if self.userId is not None:
26941 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26942 
      oprot.writeI64(self.userId)
6000 mandeep.dh 26943 
      oprot.writeFieldEnd()
26944 
    oprot.writeFieldStop()
26945 
    oprot.writeStructEnd()
26946 
 
26947 
  def validate(self):
26948 
    return
26949 
 
26950 
 
26951 
  def __repr__(self):
26952 
    L = ['%s=%r' % (key, value)
26953 
      for key, value in self.__dict__.iteritems()]
26954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26955 
 
26956 
  def __eq__(self, other):
26957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26958 
 
26959 
  def __ne__(self, other):
26960 
    return not (self == other)
26961 
 
6031 rajveer 26962 
class getUserWallet_result:
6000 mandeep.dh 26963 
  """
26964 
  Attributes:
26965 
   - success
26966 
  """
26967 
 
26968 
  thrift_spec = (
6031 rajveer 26969 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 26970 
  )
26971 
 
26972 
  def __init__(self, success=None,):
26973 
    self.success = success
26974 
 
26975 
  def read(self, iprot):
26976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26978 
      return
26979 
    iprot.readStructBegin()
26980 
    while True:
26981 
      (fname, ftype, fid) = iprot.readFieldBegin()
26982 
      if ftype == TType.STOP:
26983 
        break
26984 
      if fid == 0:
6031 rajveer 26985 
        if ftype == TType.STRUCT:
26986 
          self.success = UserWallet()
26987 
          self.success.read(iprot)
6000 mandeep.dh 26988 
        else:
26989 
          iprot.skip(ftype)
26990 
      else:
26991 
        iprot.skip(ftype)
26992 
      iprot.readFieldEnd()
26993 
    iprot.readStructEnd()
26994 
 
26995 
  def write(self, oprot):
26996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26998 
      return
6031 rajveer 26999 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27000 
    if self.success is not None:
6031 rajveer 27001 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27002 
      self.success.write(oprot)
6000 mandeep.dh 27003 
      oprot.writeFieldEnd()
27004 
    oprot.writeFieldStop()
27005 
    oprot.writeStructEnd()
27006 
 
27007 
  def validate(self):
27008 
    return
27009 
 
27010 
 
27011 
  def __repr__(self):
27012 
    L = ['%s=%r' % (key, value)
27013 
      for key, value in self.__dict__.iteritems()]
27014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27015 
 
27016 
  def __eq__(self, other):
27017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27018 
 
27019 
  def __ne__(self, other):
27020 
    return not (self == other)
27021 
 
6031 rajveer 27022 
class getUserWalletHistory_args:
6000 mandeep.dh 27023 
  """
27024 
  Attributes:
6031 rajveer 27025 
   - userId
6000 mandeep.dh 27026 
  """
27027 
 
27028 
  thrift_spec = (
27029 
    None, # 0
6031 rajveer 27030 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27031 
  )
27032 
 
6031 rajveer 27033 
  def __init__(self, userId=None,):
27034 
    self.userId = userId
6000 mandeep.dh 27035 
 
27036 
  def read(self, iprot):
27037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27039 
      return
27040 
    iprot.readStructBegin()
27041 
    while True:
27042 
      (fname, ftype, fid) = iprot.readFieldBegin()
27043 
      if ftype == TType.STOP:
27044 
        break
27045 
      if fid == 1:
27046 
        if ftype == TType.I64:
6031 rajveer 27047 
          self.userId = iprot.readI64();
6000 mandeep.dh 27048 
        else:
27049 
          iprot.skip(ftype)
27050 
      else:
27051 
        iprot.skip(ftype)
27052 
      iprot.readFieldEnd()
27053 
    iprot.readStructEnd()
27054 
 
27055 
  def write(self, oprot):
27056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27058 
      return
6031 rajveer 27059 
    oprot.writeStructBegin('getUserWalletHistory_args')
27060 
    if self.userId is not None:
27061 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27062 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27063 
      oprot.writeFieldEnd()
27064 
    oprot.writeFieldStop()
27065 
    oprot.writeStructEnd()
27066 
 
27067 
  def validate(self):
27068 
    return
27069 
 
27070 
 
27071 
  def __repr__(self):
27072 
    L = ['%s=%r' % (key, value)
27073 
      for key, value in self.__dict__.iteritems()]
27074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27075 
 
27076 
  def __eq__(self, other):
27077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27078 
 
27079 
  def __ne__(self, other):
27080 
    return not (self == other)
27081 
 
6031 rajveer 27082 
class getUserWalletHistory_result:
6000 mandeep.dh 27083 
  """
27084 
  Attributes:
27085 
   - success
27086 
  """
27087 
 
27088 
  thrift_spec = (
6031 rajveer 27089 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27090 
  )
27091 
 
27092 
  def __init__(self, success=None,):
27093 
    self.success = success
27094 
 
27095 
  def read(self, iprot):
27096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27098 
      return
27099 
    iprot.readStructBegin()
27100 
    while True:
27101 
      (fname, ftype, fid) = iprot.readFieldBegin()
27102 
      if ftype == TType.STOP:
27103 
        break
27104 
      if fid == 0:
27105 
        if ftype == TType.LIST:
27106 
          self.success = []
6031 rajveer 27107 
          (_etype623, _size620) = iprot.readListBegin()
27108 
          for _i624 in xrange(_size620):
27109 
            _elem625 = UserWalletHistory()
27110 
            _elem625.read(iprot)
27111 
            self.success.append(_elem625)
6000 mandeep.dh 27112 
          iprot.readListEnd()
27113 
        else:
27114 
          iprot.skip(ftype)
27115 
      else:
27116 
        iprot.skip(ftype)
27117 
      iprot.readFieldEnd()
27118 
    iprot.readStructEnd()
27119 
 
27120 
  def write(self, oprot):
27121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27123 
      return
6031 rajveer 27124 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27125 
    if self.success is not None:
27126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27127 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6031 rajveer 27128 
      for iter626 in self.success:
27129 
        iter626.write(oprot)
6000 mandeep.dh 27130 
      oprot.writeListEnd()
27131 
      oprot.writeFieldEnd()
27132 
    oprot.writeFieldStop()
27133 
    oprot.writeStructEnd()
27134 
 
27135 
  def validate(self):
27136 
    return
27137 
 
27138 
 
27139 
  def __repr__(self):
27140 
    L = ['%s=%r' % (key, value)
27141 
      for key, value in self.__dict__.iteritems()]
27142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27143 
 
27144 
  def __eq__(self, other):
27145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27146 
 
27147 
  def __ne__(self, other):
27148 
    return not (self == other)
6048 rajveer 27149 
 
6050 anupam.sin 27150 
class getRechargeOrdersForTransaction_args:
27151 
  """
27152 
  Attributes:
27153 
   - txnId
27154 
  """
27155 
 
27156 
  thrift_spec = (
27157 
    None, # 0
27158 
    (1, TType.I64, 'txnId', None, None, ), # 1
27159 
  )
27160 
 
27161 
  def __init__(self, txnId=None,):
27162 
    self.txnId = txnId
27163 
 
27164 
  def read(self, iprot):
27165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27167 
      return
27168 
    iprot.readStructBegin()
27169 
    while True:
27170 
      (fname, ftype, fid) = iprot.readFieldBegin()
27171 
      if ftype == TType.STOP:
27172 
        break
27173 
      if fid == 1:
27174 
        if ftype == TType.I64:
27175 
          self.txnId = iprot.readI64();
27176 
        else:
27177 
          iprot.skip(ftype)
27178 
      else:
27179 
        iprot.skip(ftype)
27180 
      iprot.readFieldEnd()
27181 
    iprot.readStructEnd()
27182 
 
27183 
  def write(self, oprot):
27184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27186 
      return
27187 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27188 
    if self.txnId is not None:
27189 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27190 
      oprot.writeI64(self.txnId)
27191 
      oprot.writeFieldEnd()
27192 
    oprot.writeFieldStop()
27193 
    oprot.writeStructEnd()
27194 
 
27195 
  def validate(self):
27196 
    return
27197 
 
27198 
 
27199 
  def __repr__(self):
27200 
    L = ['%s=%r' % (key, value)
27201 
      for key, value in self.__dict__.iteritems()]
27202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27203 
 
27204 
  def __eq__(self, other):
27205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27206 
 
27207 
  def __ne__(self, other):
27208 
    return not (self == other)
27209 
 
27210 
class getRechargeOrdersForTransaction_result:
27211 
  """
27212 
  Attributes:
27213 
   - success
27214 
   - ex
27215 
  """
27216 
 
27217 
  thrift_spec = (
27218 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27219 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27220 
  )
27221 
 
27222 
  def __init__(self, success=None, ex=None,):
27223 
    self.success = success
27224 
    self.ex = ex
27225 
 
27226 
  def read(self, iprot):
27227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27229 
      return
27230 
    iprot.readStructBegin()
27231 
    while True:
27232 
      (fname, ftype, fid) = iprot.readFieldBegin()
27233 
      if ftype == TType.STOP:
27234 
        break
27235 
      if fid == 0:
27236 
        if ftype == TType.STRUCT:
27237 
          self.success = RechargeOrder()
27238 
          self.success.read(iprot)
27239 
        else:
27240 
          iprot.skip(ftype)
27241 
      elif fid == 1:
27242 
        if ftype == TType.STRUCT:
27243 
          self.ex = TransactionServiceException()
27244 
          self.ex.read(iprot)
27245 
        else:
27246 
          iprot.skip(ftype)
27247 
      else:
27248 
        iprot.skip(ftype)
27249 
      iprot.readFieldEnd()
27250 
    iprot.readStructEnd()
27251 
 
27252 
  def write(self, oprot):
27253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27255 
      return
27256 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27257 
    if self.success is not None:
27258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27259 
      self.success.write(oprot)
27260 
      oprot.writeFieldEnd()
27261 
    if self.ex is not None:
27262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27263 
      self.ex.write(oprot)
27264 
      oprot.writeFieldEnd()
27265 
    oprot.writeFieldStop()
27266 
    oprot.writeStructEnd()
27267 
 
27268 
  def validate(self):
27269 
    return
27270 
 
27271 
 
27272 
  def __repr__(self):
27273 
    L = ['%s=%r' % (key, value)
27274 
      for key, value in self.__dict__.iteritems()]
27275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27276 
 
27277 
  def __eq__(self, other):
27278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27279 
 
27280 
  def __ne__(self, other):
27281 
    return not (self == other)
27282 
 
6048 rajveer 27283 
class getServiceProviders_args:
27284 
  """
27285 
  Attributes:
27286 
   - rechargeType
27287 
  """
27288 
 
27289 
  thrift_spec = (
27290 
    None, # 0
27291 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27292 
  )
27293 
 
27294 
  def __init__(self, rechargeType=None,):
27295 
    self.rechargeType = rechargeType
27296 
 
27297 
  def read(self, iprot):
27298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27300 
      return
27301 
    iprot.readStructBegin()
27302 
    while True:
27303 
      (fname, ftype, fid) = iprot.readFieldBegin()
27304 
      if ftype == TType.STOP:
27305 
        break
27306 
      if fid == 1:
27307 
        if ftype == TType.I32:
27308 
          self.rechargeType = iprot.readI32();
27309 
        else:
27310 
          iprot.skip(ftype)
27311 
      else:
27312 
        iprot.skip(ftype)
27313 
      iprot.readFieldEnd()
27314 
    iprot.readStructEnd()
27315 
 
27316 
  def write(self, oprot):
27317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27319 
      return
27320 
    oprot.writeStructBegin('getServiceProviders_args')
27321 
    if self.rechargeType is not None:
27322 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27323 
      oprot.writeI32(self.rechargeType)
27324 
      oprot.writeFieldEnd()
27325 
    oprot.writeFieldStop()
27326 
    oprot.writeStructEnd()
27327 
 
27328 
  def validate(self):
27329 
    return
27330 
 
27331 
 
27332 
  def __repr__(self):
27333 
    L = ['%s=%r' % (key, value)
27334 
      for key, value in self.__dict__.iteritems()]
27335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27336 
 
27337 
  def __eq__(self, other):
27338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27339 
 
27340 
  def __ne__(self, other):
27341 
    return not (self == other)
27342 
 
27343 
class getServiceProviders_result:
27344 
  """
27345 
  Attributes:
27346 
   - success
27347 
  """
27348 
 
27349 
  thrift_spec = (
27350 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27351 
  )
27352 
 
27353 
  def __init__(self, success=None,):
27354 
    self.success = success
27355 
 
27356 
  def read(self, iprot):
27357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27359 
      return
27360 
    iprot.readStructBegin()
27361 
    while True:
27362 
      (fname, ftype, fid) = iprot.readFieldBegin()
27363 
      if ftype == TType.STOP:
27364 
        break
27365 
      if fid == 0:
27366 
        if ftype == TType.MAP:
27367 
          self.success = {}
27368 
          (_ktype628, _vtype629, _size627 ) = iprot.readMapBegin()
27369 
          for _i631 in xrange(_size627):
27370 
            _key632 = iprot.readI64();
27371 
            _val633 = iprot.readString();
27372 
            self.success[_key632] = _val633
27373 
          iprot.readMapEnd()
27374 
        else:
27375 
          iprot.skip(ftype)
27376 
      else:
27377 
        iprot.skip(ftype)
27378 
      iprot.readFieldEnd()
27379 
    iprot.readStructEnd()
27380 
 
27381 
  def write(self, oprot):
27382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27384 
      return
27385 
    oprot.writeStructBegin('getServiceProviders_result')
27386 
    if self.success is not None:
27387 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27388 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
27389 
      for kiter634,viter635 in self.success.items():
27390 
        oprot.writeI64(kiter634)
27391 
        oprot.writeString(viter635)
27392 
      oprot.writeMapEnd()
27393 
      oprot.writeFieldEnd()
27394 
    oprot.writeFieldStop()
27395 
    oprot.writeStructEnd()
27396 
 
27397 
  def validate(self):
27398 
    return
27399 
 
27400 
 
27401 
  def __repr__(self):
27402 
    L = ['%s=%r' % (key, value)
27403 
      for key, value in self.__dict__.iteritems()]
27404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27405 
 
27406 
  def __eq__(self, other):
27407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27408 
 
27409 
  def __ne__(self, other):
27410 
    return not (self == other)
27411 
 
27412 
class getServiceProviderForDevice_args:
27413 
  """
27414 
  Attributes:
6049 rajveer 27415 
   - rechargeType
6048 rajveer 27416 
   - deviceNumber
27417 
  """
27418 
 
27419 
  thrift_spec = (
27420 
    None, # 0
6049 rajveer 27421 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27422 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27423 
  )
27424 
 
6049 rajveer 27425 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27426 
    self.rechargeType = rechargeType
6048 rajveer 27427 
    self.deviceNumber = deviceNumber
27428 
 
27429 
  def read(self, iprot):
27430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27432 
      return
27433 
    iprot.readStructBegin()
27434 
    while True:
27435 
      (fname, ftype, fid) = iprot.readFieldBegin()
27436 
      if ftype == TType.STOP:
27437 
        break
27438 
      if fid == 1:
6049 rajveer 27439 
        if ftype == TType.I32:
27440 
          self.rechargeType = iprot.readI32();
27441 
        else:
27442 
          iprot.skip(ftype)
27443 
      elif fid == 2:
6048 rajveer 27444 
        if ftype == TType.STRING:
27445 
          self.deviceNumber = iprot.readString();
27446 
        else:
27447 
          iprot.skip(ftype)
27448 
      else:
27449 
        iprot.skip(ftype)
27450 
      iprot.readFieldEnd()
27451 
    iprot.readStructEnd()
27452 
 
27453 
  def write(self, oprot):
27454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27456 
      return
27457 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27458 
    if self.rechargeType is not None:
27459 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27460 
      oprot.writeI32(self.rechargeType)
27461 
      oprot.writeFieldEnd()
6048 rajveer 27462 
    if self.deviceNumber is not None:
6049 rajveer 27463 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27464 
      oprot.writeString(self.deviceNumber)
27465 
      oprot.writeFieldEnd()
27466 
    oprot.writeFieldStop()
27467 
    oprot.writeStructEnd()
27468 
 
27469 
  def validate(self):
27470 
    return
27471 
 
27472 
 
27473 
  def __repr__(self):
27474 
    L = ['%s=%r' % (key, value)
27475 
      for key, value in self.__dict__.iteritems()]
27476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27477 
 
27478 
  def __eq__(self, other):
27479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27480 
 
27481 
  def __ne__(self, other):
27482 
    return not (self == other)
27483 
 
27484 
class getServiceProviderForDevice_result:
27485 
  """
27486 
  Attributes:
27487 
   - success
27488 
  """
27489 
 
27490 
  thrift_spec = (
27491 
    (0, TType.I64, 'success', None, None, ), # 0
27492 
  )
27493 
 
27494 
  def __init__(self, success=None,):
27495 
    self.success = success
27496 
 
27497 
  def read(self, iprot):
27498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27500 
      return
27501 
    iprot.readStructBegin()
27502 
    while True:
27503 
      (fname, ftype, fid) = iprot.readFieldBegin()
27504 
      if ftype == TType.STOP:
27505 
        break
27506 
      if fid == 0:
27507 
        if ftype == TType.I64:
27508 
          self.success = iprot.readI64();
27509 
        else:
27510 
          iprot.skip(ftype)
27511 
      else:
27512 
        iprot.skip(ftype)
27513 
      iprot.readFieldEnd()
27514 
    iprot.readStructEnd()
27515 
 
27516 
  def write(self, oprot):
27517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27519 
      return
27520 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27521 
    if self.success is not None:
27522 
      oprot.writeFieldBegin('success', TType.I64, 0)
27523 
      oprot.writeI64(self.success)
27524 
      oprot.writeFieldEnd()
27525 
    oprot.writeFieldStop()
27526 
    oprot.writeStructEnd()
27527 
 
27528 
  def validate(self):
27529 
    return
27530 
 
27531 
 
27532 
  def __repr__(self):
27533 
    L = ['%s=%r' % (key, value)
27534 
      for key, value in self.__dict__.iteritems()]
27535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27536 
 
27537 
  def __eq__(self, other):
27538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27539 
 
27540 
  def __ne__(self, other):
27541 
    return not (self == other)
6094 rajveer 27542 
 
27543 
class getRechargeOrdersForDevice_args:
27544 
  """
27545 
  Attributes:
27546 
   - deviceNumber
27547 
  """
27548 
 
27549 
  thrift_spec = (
27550 
    None, # 0
27551 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27552 
  )
27553 
 
27554 
  def __init__(self, deviceNumber=None,):
27555 
    self.deviceNumber = deviceNumber
27556 
 
27557 
  def read(self, iprot):
27558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27560 
      return
27561 
    iprot.readStructBegin()
27562 
    while True:
27563 
      (fname, ftype, fid) = iprot.readFieldBegin()
27564 
      if ftype == TType.STOP:
27565 
        break
27566 
      if fid == 1:
27567 
        if ftype == TType.STRING:
27568 
          self.deviceNumber = iprot.readString();
27569 
        else:
27570 
          iprot.skip(ftype)
27571 
      else:
27572 
        iprot.skip(ftype)
27573 
      iprot.readFieldEnd()
27574 
    iprot.readStructEnd()
27575 
 
27576 
  def write(self, oprot):
27577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27579 
      return
27580 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27581 
    if self.deviceNumber is not None:
27582 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27583 
      oprot.writeString(self.deviceNumber)
27584 
      oprot.writeFieldEnd()
27585 
    oprot.writeFieldStop()
27586 
    oprot.writeStructEnd()
27587 
 
27588 
  def validate(self):
27589 
    return
27590 
 
27591 
 
27592 
  def __repr__(self):
27593 
    L = ['%s=%r' % (key, value)
27594 
      for key, value in self.__dict__.iteritems()]
27595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27596 
 
27597 
  def __eq__(self, other):
27598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27599 
 
27600 
  def __ne__(self, other):
27601 
    return not (self == other)
27602 
 
27603 
class getRechargeOrdersForDevice_result:
27604 
  """
27605 
  Attributes:
27606 
   - success
27607 
  """
27608 
 
27609 
  thrift_spec = (
27610 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27611 
  )
27612 
 
27613 
  def __init__(self, success=None,):
27614 
    self.success = success
27615 
 
27616 
  def read(self, iprot):
27617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27619 
      return
27620 
    iprot.readStructBegin()
27621 
    while True:
27622 
      (fname, ftype, fid) = iprot.readFieldBegin()
27623 
      if ftype == TType.STOP:
27624 
        break
27625 
      if fid == 0:
27626 
        if ftype == TType.LIST:
27627 
          self.success = []
27628 
          (_etype639, _size636) = iprot.readListBegin()
27629 
          for _i640 in xrange(_size636):
27630 
            _elem641 = RechargeOrder()
27631 
            _elem641.read(iprot)
27632 
            self.success.append(_elem641)
27633 
          iprot.readListEnd()
27634 
        else:
27635 
          iprot.skip(ftype)
27636 
      else:
27637 
        iprot.skip(ftype)
27638 
      iprot.readFieldEnd()
27639 
    iprot.readStructEnd()
27640 
 
27641 
  def write(self, oprot):
27642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27644 
      return
27645 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
27646 
    if self.success is not None:
27647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
27649 
      for iter642 in self.success:
27650 
        iter642.write(oprot)
27651 
      oprot.writeListEnd()
27652 
      oprot.writeFieldEnd()
27653 
    oprot.writeFieldStop()
27654 
    oprot.writeStructEnd()
27655 
 
27656 
  def validate(self):
27657 
    return
27658 
 
27659 
 
27660 
  def __repr__(self):
27661 
    L = ['%s=%r' % (key, value)
27662 
      for key, value in self.__dict__.iteritems()]
27663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27664 
 
27665 
  def __eq__(self, other):
27666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27667 
 
27668 
  def __ne__(self, other):
27669 
    return not (self == other)
27670 
 
27671 
class addAmountToWallet_args:
27672 
  """
27673 
  Attributes:
27674 
   - userId
27675 
   - orderId
27676 
   - amount
27677 
  """
27678 
 
27679 
  thrift_spec = (
27680 
    None, # 0
27681 
    (1, TType.I64, 'userId', None, None, ), # 1
27682 
    (2, TType.I64, 'orderId', None, None, ), # 2
27683 
    (3, TType.I64, 'amount', None, None, ), # 3
27684 
  )
27685 
 
27686 
  def __init__(self, userId=None, orderId=None, amount=None,):
27687 
    self.userId = userId
27688 
    self.orderId = orderId
27689 
    self.amount = amount
27690 
 
27691 
  def read(self, iprot):
27692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27694 
      return
27695 
    iprot.readStructBegin()
27696 
    while True:
27697 
      (fname, ftype, fid) = iprot.readFieldBegin()
27698 
      if ftype == TType.STOP:
27699 
        break
27700 
      if fid == 1:
27701 
        if ftype == TType.I64:
27702 
          self.userId = iprot.readI64();
27703 
        else:
27704 
          iprot.skip(ftype)
27705 
      elif fid == 2:
27706 
        if ftype == TType.I64:
27707 
          self.orderId = iprot.readI64();
27708 
        else:
27709 
          iprot.skip(ftype)
27710 
      elif fid == 3:
27711 
        if ftype == TType.I64:
27712 
          self.amount = iprot.readI64();
27713 
        else:
27714 
          iprot.skip(ftype)
27715 
      else:
27716 
        iprot.skip(ftype)
27717 
      iprot.readFieldEnd()
27718 
    iprot.readStructEnd()
27719 
 
27720 
  def write(self, oprot):
27721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27723 
      return
27724 
    oprot.writeStructBegin('addAmountToWallet_args')
27725 
    if self.userId is not None:
27726 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27727 
      oprot.writeI64(self.userId)
27728 
      oprot.writeFieldEnd()
27729 
    if self.orderId is not None:
27730 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
27731 
      oprot.writeI64(self.orderId)
27732 
      oprot.writeFieldEnd()
27733 
    if self.amount is not None:
27734 
      oprot.writeFieldBegin('amount', TType.I64, 3)
27735 
      oprot.writeI64(self.amount)
27736 
      oprot.writeFieldEnd()
27737 
    oprot.writeFieldStop()
27738 
    oprot.writeStructEnd()
27739 
 
27740 
  def validate(self):
27741 
    return
27742 
 
27743 
 
27744 
  def __repr__(self):
27745 
    L = ['%s=%r' % (key, value)
27746 
      for key, value in self.__dict__.iteritems()]
27747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27748 
 
27749 
  def __eq__(self, other):
27750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27751 
 
27752 
  def __ne__(self, other):
27753 
    return not (self == other)
27754 
 
27755 
class addAmountToWallet_result:
27756 
 
27757 
  thrift_spec = (
27758 
  )
27759 
 
27760 
  def read(self, iprot):
27761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27763 
      return
27764 
    iprot.readStructBegin()
27765 
    while True:
27766 
      (fname, ftype, fid) = iprot.readFieldBegin()
27767 
      if ftype == TType.STOP:
27768 
        break
27769 
      else:
27770 
        iprot.skip(ftype)
27771 
      iprot.readFieldEnd()
27772 
    iprot.readStructEnd()
27773 
 
27774 
  def write(self, oprot):
27775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27777 
      return
27778 
    oprot.writeStructBegin('addAmountToWallet_result')
27779 
    oprot.writeFieldStop()
27780 
    oprot.writeStructEnd()
27781 
 
27782 
  def validate(self):
27783 
    return
27784 
 
27785 
 
27786 
  def __repr__(self):
27787 
    L = ['%s=%r' % (key, value)
27788 
      for key, value in self.__dict__.iteritems()]
27789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27790 
 
27791 
  def __eq__(self, other):
27792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27793 
 
27794 
  def __ne__(self, other):
27795 
    return not (self == other)